Echidna Coverage Report

Files

    Files
    42
    Total Lines
    26575
    Coverage
    24.0%
    278 / 1152 lines
    Actions
    50.0% lib/forge-std/src/Base.sol
    Lines covered: 1 / 2 (50.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    import {StdStorage} from "./StdStorage.sol";
    5
    import {Vm, VmSafe} from "./Vm.sol";
    6
    7
    abstract contract CommonBase {
    8
        /// @dev Cheat code address.
    9
        /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
    10
        address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;
    11
    12
        /// @dev console.sol and console2.sol work by executing a staticcall to this address.
    13
        /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
    14
        address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
    15
    16
        /// @dev Used when deploying with create2.
    17
        /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
    18
        address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    19
    20
        /// @dev The default address for tx.origin and msg.sender.
    21
        /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
    22
        address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
    23
    24
        /// @dev The address of the first contract `CREATE`d by a running test contract.
    25
        /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
    26
        /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
    27
        address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
    28
    29
        /// @dev Deterministic deployment address of the Multicall3 contract.
    30
        /// Taken from https://www.multicall3.com.
    31
        address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
    32
    33
        /// @dev The order of the secp256k1 curve.
    34
        uint256 internal constant SECP256K1_ORDER =
    35
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    36
    37
        uint256 internal constant UINT256_MAX =
    38
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    39
    40
        Vm internal constant vm = Vm(VM_ADDRESS);
    41
        StdStorage internal stdstore;
    42
    }
    43
    44
    abstract contract TestBase is CommonBase {}
    45
    46
    abstract contract ScriptBase is CommonBase {
    47
        VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
    48
    }
    49
    88.0% lib/forge-std/src/StdAssertions.sol
    Lines covered: 8 / 9 (88.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    pragma experimental ABIEncoderV2;
    4
    5
    import {Vm} from "./Vm.sol";
    6
    7
    abstract contract StdAssertions {
    8
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    9
    10
        event log(string);
    11
        event logs(bytes);
    12
    13
        event log_address(address);
    14
        event log_bytes32(bytes32);
    15
        event log_int(int256);
    16
        event log_uint(uint256);
    17
        event log_bytes(bytes);
    18
        event log_string(string);
    19
    20
        event log_named_address(string key, address val);
    21
        event log_named_bytes32(string key, bytes32 val);
    22
        event log_named_decimal_int(string key, int256 val, uint256 decimals);
    23
        event log_named_decimal_uint(string key, uint256 val, uint256 decimals);
    24
        event log_named_int(string key, int256 val);
    25
        event log_named_uint(string key, uint256 val);
    26
        event log_named_bytes(string key, bytes val);
    27
        event log_named_string(string key, string val);
    28
    29
        event log_array(uint256[] val);
    30
        event log_array(int256[] val);
    31
        event log_array(address[] val);
    32
        event log_named_array(string key, uint256[] val);
    33
        event log_named_array(string key, int256[] val);
    34
        event log_named_array(string key, address[] val);
    35
    36
        bytes32 private constant FAILED_SLOT = bytes32("failed");
    37
    38
        bool private _failed;
    39
    40
        function failed() public view returns (bool) {
    41
            if (_failed) {
    42
                return true;
    43
            } else {
    44
                return vm.load(address(vm), FAILED_SLOT) != bytes32(0);
    45
            }
    46
        }
    47
    48
        function fail() internal virtual {
    49
            vm.store(address(vm), FAILED_SLOT, bytes32(uint256(1)));
    50
            _failed = true;
    51
        }
    52
    53
        function fail(string memory message) internal virtual {
    54
            fail();
    55
            vm.assertTrue(false, message);
    56
        }
    57
    58
        function assertTrue(bool data) internal pure virtual {
    59
            if (!data) {
    60
                vm.assertTrue(data);
    61
            }
    62
        }
    63
    64
        function assertTrue(bool data, string memory err) internal pure virtual {
    65
            if (!data) {
    66
                vm.assertTrue(data, err);
    67
            }
    68
        }
    69
    70
        function assertFalse(bool data) internal pure virtual {
    71
            if (data) {
    72
                vm.assertFalse(data);
    73
            }
    74
        }
    75
    76
        function assertFalse(bool data, string memory err) internal pure virtual {
    77
            if (data) {
    78
                vm.assertFalse(data, err);
    79
            }
    80
        }
    81
    82
        function assertEq(bool left, bool right) internal pure virtual {
    83
            if (left != right) {
    84
                vm.assertEq(left, right);
    85
            }
    86
        }
    87
    88
        function assertEq(bool left, bool right, string memory err) internal pure virtual {
    89
            if (left != right) {
    90
                vm.assertEq(left, right, err);
    91
            }
    92
        }
    93
    94
        function assertEq(uint256 left, uint256 right) internal pure virtual {
    95
            if (left != right) {
    96
                vm.assertEq(left, right);
    97
            }
    98
        }
    99
    100
        function assertEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    101
            if (left != right) {
    102
                vm.assertEq(left, right, err);
    103
            }
    104
        }
    105
    106
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    107
            vm.assertEqDecimal(left, right, decimals);
    108
        }
    109
    110
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    111
            vm.assertEqDecimal(left, right, decimals, err);
    112
        }
    113
    114
        function assertEq(int256 left, int256 right) internal pure virtual {
    115
            if (left != right) {
    116
                vm.assertEq(left, right);
    117
            }
    118
        }
    119
    120
        function assertEq(int256 left, int256 right, string memory err) internal pure virtual {
    121
            if (left != right) {
    122
                vm.assertEq(left, right, err);
    123
            }
    124
        }
    125
    126
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    127
            vm.assertEqDecimal(left, right, decimals);
    128
        }
    129
    130
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    131
            vm.assertEqDecimal(left, right, decimals, err);
    132
        }
    133
    134
        function assertEq(address left, address right) internal pure virtual {
    135
            if (left != right) {
    136
                vm.assertEq(left, right);
    137
            }
    138
        }
    139
    140
        function assertEq(address left, address right, string memory err) internal pure virtual {
    141
            if (left != right) {
    142
                vm.assertEq(left, right, err);
    143
            }
    144
        }
    145
    146
        function assertEq(bytes32 left, bytes32 right) internal pure virtual {
    147
            if (left != right) {
    148
                vm.assertEq(left, right);
    149
            }
    150
        }
    151
    152
        function assertEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    153
            if (left != right) {
    154
                vm.assertEq(left, right, err);
    155
            }
    156
        }
    157
    158
        function assertEq32(bytes32 left, bytes32 right) internal pure virtual {
    159
            if (left != right) {
    160
                vm.assertEq(left, right);
    161
            }
    162
        }
    163
    164
        function assertEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    165
            if (left != right) {
    166
                vm.assertEq(left, right, err);
    167
            }
    168
        }
    169
    170
        function assertEq(string memory left, string memory right) internal pure virtual {
    171
            vm.assertEq(left, right);
    172
        }
    173
    174
        function assertEq(string memory left, string memory right, string memory err) internal pure virtual {
    175
            vm.assertEq(left, right, err);
    176
        }
    177
    178
        function assertEq(bytes memory left, bytes memory right) internal pure virtual {
    179
            vm.assertEq(left, right);
    180
        }
    181
    182
        function assertEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    183
            vm.assertEq(left, right, err);
    184
        }
    185
    186
        function assertEq(bool[] memory left, bool[] memory right) internal pure virtual {
    187
            vm.assertEq(left, right);
    188
        }
    189
    190
        function assertEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    191
            vm.assertEq(left, right, err);
    192
        }
    193
    194
        function assertEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    195
            vm.assertEq(left, right);
    196
        }
    197
    198
        function assertEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    199
            vm.assertEq(left, right, err);
    200
        }
    201
    202
        function assertEq(int256[] memory left, int256[] memory right) internal pure virtual {
    203
            vm.assertEq(left, right);
    204
        }
    205
    206
        function assertEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    207
            vm.assertEq(left, right, err);
    208
        }
    209
    210
        function assertEq(address[] memory left, address[] memory right) internal pure virtual {
    211
            vm.assertEq(left, right);
    212
        }
    213
    214
        function assertEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    215
            vm.assertEq(left, right, err);
    216
        }
    217
    218
        function assertEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    219
            vm.assertEq(left, right);
    220
        }
    221
    222
        function assertEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    223
            vm.assertEq(left, right, err);
    224
        }
    225
    226
        function assertEq(string[] memory left, string[] memory right) internal pure virtual {
    227
            vm.assertEq(left, right);
    228
        }
    229
    230
        function assertEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    231
            vm.assertEq(left, right, err);
    232
        }
    233
    234
        function assertEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    235
            vm.assertEq(left, right);
    236
        }
    237
    238
        function assertEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    239
            vm.assertEq(left, right, err);
    240
        }
    241
    242
        // Legacy helper
    243
        function assertEqUint(uint256 left, uint256 right) internal pure virtual {
    244
            assertEq(left, right);
    245
        }
    246
    247
        function assertNotEq(bool left, bool right) internal pure virtual {
    248
            if (left == right) {
    249
                vm.assertNotEq(left, right);
    250
            }
    251
        }
    252
    253
        function assertNotEq(bool left, bool right, string memory err) internal pure virtual {
    254
            if (left == right) {
    255
                vm.assertNotEq(left, right, err);
    256
            }
    257
        }
    258
    259
        function assertNotEq(uint256 left, uint256 right) internal pure virtual {
    260
            if (left == right) {
    261
                vm.assertNotEq(left, right);
    262
            }
    263
        }
    264
    265
        function assertNotEq(uint256 left, uint256 right, string memory err) internal pure virtual {
    266
            if (left == right) {
    267
                vm.assertNotEq(left, right, err);
    268
            }
    269
        }
    270
    271
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    272
            vm.assertNotEqDecimal(left, right, decimals);
    273
        }
    274
    275
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string memory err)
    276
            internal
    277
            pure
    278
            virtual
    279
        {
    280
            vm.assertNotEqDecimal(left, right, decimals, err);
    281
        }
    282
    283
        function assertNotEq(int256 left, int256 right) internal pure virtual {
    284
            if (left == right) {
    285
                vm.assertNotEq(left, right);
    286
            }
    287
        }
    288
    289
        function assertNotEq(int256 left, int256 right, string memory err) internal pure virtual {
    290
            if (left == right) {
    291
                vm.assertNotEq(left, right, err);
    292
            }
    293
        }
    294
    295
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    296
            vm.assertNotEqDecimal(left, right, decimals);
    297
        }
    298
    299
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    300
            vm.assertNotEqDecimal(left, right, decimals, err);
    301
        }
    302
    303
        function assertNotEq(address left, address right) internal pure virtual {
    304
            if (left == right) {
    305
                vm.assertNotEq(left, right);
    306
            }
    307
        }
    308
    309
        function assertNotEq(address left, address right, string memory err) internal pure virtual {
    310
            if (left == right) {
    311
                vm.assertNotEq(left, right, err);
    312
            }
    313
        }
    314
    315
        function assertNotEq(bytes32 left, bytes32 right) internal pure virtual {
    316
            if (left == right) {
    317
                vm.assertNotEq(left, right);
    318
            }
    319
        }
    320
    321
        function assertNotEq(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    322
            if (left == right) {
    323
                vm.assertNotEq(left, right, err);
    324
            }
    325
        }
    326
    327
        function assertNotEq32(bytes32 left, bytes32 right) internal pure virtual {
    328
            if (left == right) {
    329
                vm.assertNotEq(left, right);
    330
            }
    331
        }
    332
    333
        function assertNotEq32(bytes32 left, bytes32 right, string memory err) internal pure virtual {
    334
            if (left == right) {
    335
                vm.assertNotEq(left, right, err);
    336
            }
    337
        }
    338
    339
        function assertNotEq(string memory left, string memory right) internal pure virtual {
    340
            vm.assertNotEq(left, right);
    341
        }
    342
    343
        function assertNotEq(string memory left, string memory right, string memory err) internal pure virtual {
    344
            vm.assertNotEq(left, right, err);
    345
        }
    346
    347
        function assertNotEq(bytes memory left, bytes memory right) internal pure virtual {
    348
            vm.assertNotEq(left, right);
    349
        }
    350
    351
        function assertNotEq(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    352
            vm.assertNotEq(left, right, err);
    353
        }
    354
    355
        function assertNotEq(bool[] memory left, bool[] memory right) internal pure virtual {
    356
            vm.assertNotEq(left, right);
    357
        }
    358
    359
        function assertNotEq(bool[] memory left, bool[] memory right, string memory err) internal pure virtual {
    360
            vm.assertNotEq(left, right, err);
    361
        }
    362
    363
        function assertNotEq(uint256[] memory left, uint256[] memory right) internal pure virtual {
    364
            vm.assertNotEq(left, right);
    365
        }
    366
    367
        function assertNotEq(uint256[] memory left, uint256[] memory right, string memory err) internal pure virtual {
    368
            vm.assertNotEq(left, right, err);
    369
        }
    370
    371
        function assertNotEq(int256[] memory left, int256[] memory right) internal pure virtual {
    372
            vm.assertNotEq(left, right);
    373
        }
    374
    375
        function assertNotEq(int256[] memory left, int256[] memory right, string memory err) internal pure virtual {
    376
            vm.assertNotEq(left, right, err);
    377
        }
    378
    379
        function assertNotEq(address[] memory left, address[] memory right) internal pure virtual {
    380
            vm.assertNotEq(left, right);
    381
        }
    382
    383
        function assertNotEq(address[] memory left, address[] memory right, string memory err) internal pure virtual {
    384
            vm.assertNotEq(left, right, err);
    385
        }
    386
    387
        function assertNotEq(bytes32[] memory left, bytes32[] memory right) internal pure virtual {
    388
            vm.assertNotEq(left, right);
    389
        }
    390
    391
        function assertNotEq(bytes32[] memory left, bytes32[] memory right, string memory err) internal pure virtual {
    392
            vm.assertNotEq(left, right, err);
    393
        }
    394
    395
        function assertNotEq(string[] memory left, string[] memory right) internal pure virtual {
    396
            vm.assertNotEq(left, right);
    397
        }
    398
    399
        function assertNotEq(string[] memory left, string[] memory right, string memory err) internal pure virtual {
    400
            vm.assertNotEq(left, right, err);
    401
        }
    402
    403
        function assertNotEq(bytes[] memory left, bytes[] memory right) internal pure virtual {
    404
            vm.assertNotEq(left, right);
    405
        }
    406
    407
        function assertNotEq(bytes[] memory left, bytes[] memory right, string memory err) internal pure virtual {
    408
            vm.assertNotEq(left, right, err);
    409
        }
    410
    411
        function assertLt(uint256 left, uint256 right) internal pure virtual {
    412
            if (left >= right) {
    413
                vm.assertLt(left, right);
    414
            }
    415
        }
    416
    417
        function assertLt(uint256 left, uint256 right, string memory err) internal pure virtual {
    418
            if (left >= right) {
    419
                vm.assertLt(left, right, err);
    420
            }
    421
        }
    422
    423
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    424
            vm.assertLtDecimal(left, right, decimals);
    425
        }
    426
    427
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    428
            vm.assertLtDecimal(left, right, decimals, err);
    429
        }
    430
    431
        function assertLt(int256 left, int256 right) internal pure virtual {
    432
            if (left >= right) {
    433
                vm.assertLt(left, right);
    434
            }
    435
        }
    436
    437
        function assertLt(int256 left, int256 right, string memory err) internal pure virtual {
    438
            if (left >= right) {
    439
                vm.assertLt(left, right, err);
    440
            }
    441
        }
    442
    443
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    444
            vm.assertLtDecimal(left, right, decimals);
    445
        }
    446
    447
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    448
            vm.assertLtDecimal(left, right, decimals, err);
    449
        }
    450
    451
        function assertGt(uint256 left, uint256 right) internal pure virtual {
    452
            if (left <= right) {
    453
                vm.assertGt(left, right);
    454
            }
    455
        }
    456
    457
        function assertGt(uint256 left, uint256 right, string memory err) internal pure virtual {
    458
            if (left <= right) {
    459
                vm.assertGt(left, right, err);
    460
            }
    461
        }
    462
    463
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    464
            vm.assertGtDecimal(left, right, decimals);
    465
        }
    466
    467
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    468
            vm.assertGtDecimal(left, right, decimals, err);
    469
        }
    470
    471
        function assertGt(int256 left, int256 right) internal pure virtual {
    472
            if (left <= right) {
    473
                vm.assertGt(left, right);
    474
            }
    475
        }
    476
    477
        function assertGt(int256 left, int256 right, string memory err) internal pure virtual {
    478
            if (left <= right) {
    479
                vm.assertGt(left, right, err);
    480
            }
    481
        }
    482
    483
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    484
            vm.assertGtDecimal(left, right, decimals);
    485
        }
    486
    487
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    488
            vm.assertGtDecimal(left, right, decimals, err);
    489
        }
    490
    491
        function assertLe(uint256 left, uint256 right) internal pure virtual {
    492
            if (left > right) {
    493
                vm.assertLe(left, right);
    494
            }
    495
        }
    496
    497
        function assertLe(uint256 left, uint256 right, string memory err) internal pure virtual {
    498
            if (left > right) {
    499
                vm.assertLe(left, right, err);
    500
            }
    501
        }
    502
    503
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    504
            vm.assertLeDecimal(left, right, decimals);
    505
        }
    506
    507
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    508
            vm.assertLeDecimal(left, right, decimals, err);
    509
        }
    510
    511
        function assertLe(int256 left, int256 right) internal pure virtual {
    512
            if (left > right) {
    513
                vm.assertLe(left, right);
    514
            }
    515
        }
    516
    517
        function assertLe(int256 left, int256 right, string memory err) internal pure virtual {
    518
            if (left > right) {
    519
                vm.assertLe(left, right, err);
    520
            }
    521
        }
    522
    523
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    524
            vm.assertLeDecimal(left, right, decimals);
    525
        }
    526
    527
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    528
            vm.assertLeDecimal(left, right, decimals, err);
    529
        }
    530
    531
        function assertGe(uint256 left, uint256 right) internal pure virtual {
    532
            if (left < right) {
    533
                vm.assertGe(left, right);
    534
            }
    535
        }
    536
    537
        function assertGe(uint256 left, uint256 right, string memory err) internal pure virtual {
    538
            if (left < right) {
    539
                vm.assertGe(left, right, err);
    540
            }
    541
        }
    542
    543
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) internal pure virtual {
    544
            vm.assertGeDecimal(left, right, decimals);
    545
        }
    546
    547
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string memory err) internal pure virtual {
    548
            vm.assertGeDecimal(left, right, decimals, err);
    549
        }
    550
    551
        function assertGe(int256 left, int256 right) internal pure virtual {
    552
            if (left < right) {
    553
                vm.assertGe(left, right);
    554
            }
    555
        }
    556
    557
        function assertGe(int256 left, int256 right, string memory err) internal pure virtual {
    558
            if (left < right) {
    559
                vm.assertGe(left, right, err);
    560
            }
    561
        }
    562
    563
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) internal pure virtual {
    564
            vm.assertGeDecimal(left, right, decimals);
    565
        }
    566
    567
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string memory err) internal pure virtual {
    568
            vm.assertGeDecimal(left, right, decimals, err);
    569
        }
    570
    571
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) internal pure virtual {
    572
            vm.assertApproxEqAbs(left, right, maxDelta);
    573
        }
    574
    575
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string memory err) internal pure virtual {
    576
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    577
        }
    578
    579
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals)
    580
            internal
    581
            pure
    582
            virtual
    583
        {
    584
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    585
        }
    586
    587
        function assertApproxEqAbsDecimal(
    588
            uint256 left,
    589
            uint256 right,
    590
            uint256 maxDelta,
    591
            uint256 decimals,
    592
            string memory err
    593
        ) internal pure virtual {
    594
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    595
        }
    596
    597
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) internal pure virtual {
    598
            vm.assertApproxEqAbs(left, right, maxDelta);
    599
        }
    600
    601
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string memory err) internal pure virtual {
    602
            vm.assertApproxEqAbs(left, right, maxDelta, err);
    603
        }
    604
    605
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals)
    606
            internal
    607
            pure
    608
            virtual
    609
        {
    610
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals);
    611
        }
    612
    613
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string memory err)
    614
            internal
    615
            pure
    616
            virtual
    617
        {
    618
            vm.assertApproxEqAbsDecimal(left, right, maxDelta, decimals, err);
    619
        }
    620
    621
        function assertApproxEqRel(
    622
            uint256 left,
    623
            uint256 right,
    624
            uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
    625
        )
    626
            internal
    627
            pure
    628
            virtual
    629
        {
    630
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    631
        }
    632
    633
        function assertApproxEqRel(
    634
            uint256 left,
    635
            uint256 right,
    636
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    637
            string memory err
    638
        )
    639
            internal
    640
            pure
    641
            virtual
    642
        {
    643
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    644
        }
    645
    646
        function assertApproxEqRelDecimal(
    647
            uint256 left,
    648
            uint256 right,
    649
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    650
            uint256 decimals
    651
        )
    652
            internal
    653
            pure
    654
            virtual
    655
        {
    656
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    657
        }
    658
    659
        function assertApproxEqRelDecimal(
    660
            uint256 left,
    661
            uint256 right,
    662
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    663
            uint256 decimals,
    664
            string memory err
    665
        ) internal pure virtual {
    666
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    667
        }
    668
    669
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) internal pure virtual {
    670
            vm.assertApproxEqRel(left, right, maxPercentDelta);
    671
        }
    672
    673
        function assertApproxEqRel(
    674
            int256 left,
    675
            int256 right,
    676
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    677
            string memory err
    678
        )
    679
            internal
    680
            pure
    681
            virtual
    682
        {
    683
            vm.assertApproxEqRel(left, right, maxPercentDelta, err);
    684
        }
    685
    686
        function assertApproxEqRelDecimal(
    687
            int256 left,
    688
            int256 right,
    689
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    690
            uint256 decimals
    691
        )
    692
            internal
    693
            pure
    694
            virtual
    695
        {
    696
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals);
    697
        }
    698
    699
        function assertApproxEqRelDecimal(
    700
            int256 left,
    701
            int256 right,
    702
            uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
    703
            uint256 decimals,
    704
            string memory err
    705
        ) internal pure virtual {
    706
            vm.assertApproxEqRelDecimal(left, right, maxPercentDelta, decimals, err);
    707
        }
    708
    709
        // Inherited from DSTest, not used but kept for backwards-compatibility
    710
        function checkEq0(bytes memory left, bytes memory right) internal pure returns (bool) {
    711
            return keccak256(left) == keccak256(right);
    712
        }
    713
    714
        function assertEq0(bytes memory left, bytes memory right) internal pure virtual {
    715
            assertEq(left, right);
    716
        }
    717
    718
        function assertEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    719
            assertEq(left, right, err);
    720
        }
    721
    722
        function assertNotEq0(bytes memory left, bytes memory right) internal pure virtual {
    723
            assertNotEq(left, right);
    724
        }
    725
    726
        function assertNotEq0(bytes memory left, bytes memory right, string memory err) internal pure virtual {
    727
            assertNotEq(left, right, err);
    728
        }
    729
    730
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
    731
            assertEqCall(target, callDataA, target, callDataB, true);
    732
        }
    733
    734
        function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
    735
            internal
    736
            virtual
    737
        {
    738
            assertEqCall(targetA, callDataA, targetB, callDataB, true);
    739
        }
    740
    741
        function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
    742
            internal
    743
            virtual
    744
        {
    745
            assertEqCall(target, callDataA, target, callDataB, strictRevertData);
    746
        }
    747
    748
        function assertEqCall(
    749
            address targetA,
    750
            bytes memory callDataA,
    751
            address targetB,
    752
            bytes memory callDataB,
    753
            bool strictRevertData
    754
        ) internal virtual {
    755
            (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
    756
            (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
    757
    758
            if (successA && successB) {
    759
                assertEq(returnDataA, returnDataB, "Call return data does not match");
    760
            }
    761
    762
            if (!successA && !successB && strictRevertData) {
    763
                assertEq(returnDataA, returnDataB, "Call revert data does not match");
    764
            }
    765
    766
            if (!successA && successB) {
    767
                emit log("Error: Calls were not equal");
    768
                emit log_named_bytes("  Left call revert data", returnDataA);
    769
                emit log_named_bytes(" Right call return data", returnDataB);
    770
                revert("assertion failed");
    771
            }
    772
    773
            if (successA && !successB) {
    774
                emit log("Error: Calls were not equal");
    775
                emit log_named_bytes("  Left call return data", returnDataA);
    776
                emit log_named_bytes(" Right call revert data", returnDataB);
    777
                revert("assertion failed");
    778
            }
    779
        }
    780
    }
    781
    100.0% lib/forge-std/src/StdChains.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    pragma experimental ABIEncoderV2;
    4
    5
    import {VmSafe} from "./Vm.sol";
    6
    7
    /**
    8
     * StdChains provides information about EVM compatible chains that can be used in scripts/tests.
    9
     * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
    10
     * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
    11
     * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
    12
     * alias used in this contract, which can be found as the first argument to the
    13
     * `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.
    14
     *
    15
     * There are two main ways to use this contract:
    16
     *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
    17
     *      `setChain(string memory chainAlias, Chain memory chain)`
    18
     *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
    19
     *
    20
     * The first time either of those are used, chains are initialized with the default set of RPC URLs.
    21
     * This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
    22
     * `defaultRpcUrls`.
    23
     *
    24
     * The `setChain` function is straightforward, and it simply saves off the given chain data.
    25
     *
    26
     * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
    27
     * we want to retrieve the RPC URL for `mainnet`:
    28
     *   - If you have specified data with `setChain`, it will return that.
    29
     *   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
    30
     *     is valid (e.g. a URL is specified, or an environment variable is given and exists).
    31
     *   - If neither of the above conditions is met, the default data is returned.
    32
     *
    33
     * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
    34
     */
    35
    abstract contract StdChains {
    36
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    37
    38
        bool private stdChainsInitialized;
    39
    40
        struct ChainData {
    41
            string name;
    42
            uint256 chainId;
    43
            string rpcUrl;
    44
        }
    45
    46
        struct Chain {
    47
            // The chain name.
    48
            string name;
    49
            // The chain's Chain ID.
    50
            uint256 chainId;
    51
            // The chain's alias. (i.e. what gets specified in `foundry.toml`).
    52
            string chainAlias;
    53
            // A default RPC endpoint for this chain.
    54
            // NOTE: This default RPC URL is included for convenience to facilitate quick tests and
    55
            // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
    56
            // usage as you will be throttled and this is a disservice to others who need this endpoint.
    57
            string rpcUrl;
    58
        }
    59
    60
        // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
    61
        mapping(string => Chain) private chains;
    62
        // Maps from the chain's alias to it's default RPC URL.
    63
        mapping(string => string) private defaultRpcUrls;
    64
        // Maps from a chain ID to it's alias.
    65
        mapping(uint256 => string) private idToAlias;
    66
    67
        bool private fallbackToDefaultRpcUrls = true;
    68
    69
        // The RPC URL will be fetched from config or defaultRpcUrls if possible.
    70
        function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
    71
            require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
    72
    73
            initializeStdChains();
    74
            chain = chains[chainAlias];
    75
            require(
    76
                chain.chainId != 0,
    77
                string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
    78
            );
    79
    80
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    81
        }
    82
    83
        function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
    84
            require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
    85
            initializeStdChains();
    86
            string memory chainAlias = idToAlias[chainId];
    87
    88
            chain = chains[chainAlias];
    89
    90
            require(
    91
                chain.chainId != 0,
    92
                string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
    93
            );
    94
    95
            chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
    96
        }
    97
    98
        // set chain info, with priority to argument's rpcUrl field.
    99
        function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
    100
            require(
    101
                bytes(chainAlias).length != 0,
    102
                "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
    103
            );
    104
    105
            require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
    106
    107
            initializeStdChains();
    108
            string memory foundAlias = idToAlias[chain.chainId];
    109
    110
            require(
    111
                bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
    112
                string(
    113
                    abi.encodePacked(
    114
                        "StdChains setChain(string,ChainData): Chain ID ",
    115
                        vm.toString(chain.chainId),
    116
                        " already used by \"",
    117
                        foundAlias,
    118
                        "\"."
    119
                    )
    120
                )
    121
            );
    122
    123
            uint256 oldChainId = chains[chainAlias].chainId;
    124
            delete idToAlias[oldChainId];
    125
    126
            chains[chainAlias] =
    127
                Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
    128
            idToAlias[chain.chainId] = chainAlias;
    129
        }
    130
    131
        // set chain info, with priority to argument's rpcUrl field.
    132
        function setChain(string memory chainAlias, Chain memory chain) internal virtual {
    133
            setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
    134
        }
    135
    136
        function _toUpper(string memory str) private pure returns (string memory) {
    137
            bytes memory strb = bytes(str);
    138
            bytes memory copy = new bytes(strb.length);
    139
            for (uint256 i = 0; i < strb.length; i++) {
    140
                bytes1 b = strb[i];
    141
                if (b >= 0x61 && b <= 0x7A) {
    142
                    copy[i] = bytes1(uint8(b) - 32);
    143
                } else {
    144
                    copy[i] = b;
    145
                }
    146
            }
    147
            return string(copy);
    148
        }
    149
    150
        // lookup rpcUrl, in descending order of priority:
    151
        // current -> config (foundry.toml) -> environment variable -> default
    152
        function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)
    153
            private
    154
            view
    155
            returns (Chain memory)
    156
        {
    157
            if (bytes(chain.rpcUrl).length == 0) {
    158
                try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
    159
                    chain.rpcUrl = configRpcUrl;
    160
                } catch (bytes memory err) {
    161
                    string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
    162
                    if (fallbackToDefaultRpcUrls) {
    163
                        chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
    164
                    } else {
    165
                        chain.rpcUrl = vm.envString(envName);
    166
                    }
    167
                    // Distinguish 'not found' from 'cannot read'
    168
                    // The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
    169
                    bytes memory oldNotFoundError =
    170
                        abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
    171
                    bytes memory newNotFoundError = abi.encodeWithSignature(
    172
                        "CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
    173
                    );
    174
                    bytes32 errHash = keccak256(err);
    175
                    if (
    176
                        (errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
    177
                            || bytes(chain.rpcUrl).length == 0
    178
                    ) {
    179
                        /// @solidity memory-safe-assembly
    180
                        assembly {
    181
                            revert(add(32, err), mload(err))
    182
                        }
    183
                    }
    184
                }
    185
            }
    186
            return chain;
    187
        }
    188
    189
        function setFallbackToDefaultRpcUrls(bool useDefault) internal {
    190
            fallbackToDefaultRpcUrls = useDefault;
    191
        }
    192
    193
        function initializeStdChains() private {
    194
            if (stdChainsInitialized) return;
    195
    196
            stdChainsInitialized = true;
    197
    198
            // If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`
    199
            setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
    200
            setChainWithDefaultRpcUrl("mainnet", ChainData("Mainnet", 1, "https://eth.llamarpc.com"));
    201
            setChainWithDefaultRpcUrl(
    202
                "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
    203
            );
    204
            setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));
    205
            setChainWithDefaultRpcUrl("hoodi", ChainData("Hoodi", 560048, "https://rpc.hoodi.ethpandaops.io"));
    206
            setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
    207
            setChainWithDefaultRpcUrl(
    208
                "optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")
    209
            );
    210
            setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
    211
            setChainWithDefaultRpcUrl(
    212
                "arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")
    213
            );
    214
            setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
    215
            setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
    216
            setChainWithDefaultRpcUrl(
    217
                "polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")
    218
            );
    219
            setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
    220
            setChainWithDefaultRpcUrl(
    221
                "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
    222
            );
    223
            setChainWithDefaultRpcUrl(
    224
                "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
    225
            );
    226
            setChainWithDefaultRpcUrl(
    227
                "bnb_smart_chain_testnet",
    228
                ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
    229
            );
    230
            setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
    231
            setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
    232
            setChainWithDefaultRpcUrl(
    233
                "moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
    234
            );
    235
            setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
    236
            setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));
    237
            setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
    238
            setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));
    239
            setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));
    240
            setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));
    241
            setChainWithDefaultRpcUrl(
    242
                "fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")
    243
            );
    244
            setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));
    245
            setChainWithDefaultRpcUrl("fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com"));
    246
            setChainWithDefaultRpcUrl(
    247
                "berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")
    248
            );
    249
            setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));
    250
            setChainWithDefaultRpcUrl(
    251
                "flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")
    252
            );
    253
    254
            setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org"));
    255
            setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network"));
    256
    257
            setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org"));
    258
            setChainWithDefaultRpcUrl(
    259
                "zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy")
    260
            );
    261
    262
            setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io"));
    263
            setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io"));
    264
    265
            setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org"));
    266
            setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com"));
    267
    268
            setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com"));
    269
            setChainWithDefaultRpcUrl(
    270
                "binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com")
    271
            );
    272
    273
            setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network"));
    274
            setChainWithDefaultRpcUrl(
    275
                "orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org")
    276
            );
    277
    278
            setChainWithDefaultRpcUrl("unichain", ChainData("Unichain", 130, "https://mainnet.unichain.org"));
    279
            setChainWithDefaultRpcUrl(
    280
                "unichain_sepolia", ChainData("Unichain Sepolia", 1301, "https://sepolia.unichain.org")
    281
            );
    282
        }
    283
    284
        // set chain info, with priority to chainAlias' rpc url in foundry.toml
    285
        function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
    286
            string memory rpcUrl = chain.rpcUrl;
    287
            defaultRpcUrls[chainAlias] = rpcUrl;
    288
            chain.rpcUrl = "";
    289
            setChain(chainAlias, chain);
    290
            chain.rpcUrl = rpcUrl; // restore argument
    291
        }
    292
    }
    293
    100.0% lib/forge-std/src/StdCheats.sol
    Lines covered: 4 / 4 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    7
    import {console2} from "./console2.sol";
    8
    import {Vm} from "./Vm.sol";
    9
    10
    abstract contract StdCheatsSafe {
    11
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    12
    13
        uint256 private constant UINT256_MAX =
    14
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    15
    16
        bool private gasMeteringOff;
    17
    18
        // Data structures to parse Transaction objects from the broadcast artifact
    19
        // that conform to EIP1559. The Raw structs is what is parsed from the JSON
    20
        // and then converted to the one that is used by the user for better UX.
    21
    22
        struct RawTx1559 {
    23
            string[] arguments;
    24
            address contractAddress;
    25
            string contractName;
    26
            // json value name = function
    27
            string functionSig;
    28
            bytes32 hash;
    29
            // json value name = tx
    30
            RawTx1559Detail txDetail;
    31
            // json value name = type
    32
            string opcode;
    33
        }
    34
    35
        struct RawTx1559Detail {
    36
            AccessList[] accessList;
    37
            bytes data;
    38
            address from;
    39
            bytes gas;
    40
            bytes nonce;
    41
            address to;
    42
            bytes txType;
    43
            bytes value;
    44
        }
    45
    46
        struct Tx1559 {
    47
            string[] arguments;
    48
            address contractAddress;
    49
            string contractName;
    50
            string functionSig;
    51
            bytes32 hash;
    52
            Tx1559Detail txDetail;
    53
            string opcode;
    54
        }
    55
    56
        struct Tx1559Detail {
    57
            AccessList[] accessList;
    58
            bytes data;
    59
            address from;
    60
            uint256 gas;
    61
            uint256 nonce;
    62
            address to;
    63
            uint256 txType;
    64
            uint256 value;
    65
        }
    66
    67
        // Data structures to parse Transaction objects from the broadcast artifact
    68
        // that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON
    69
        // and then converted to the one that is used by the user for better UX.
    70
    71
        struct TxLegacy {
    72
            string[] arguments;
    73
            address contractAddress;
    74
            string contractName;
    75
            string functionSig;
    76
            string hash;
    77
            string opcode;
    78
            TxDetailLegacy transaction;
    79
        }
    80
    81
        struct TxDetailLegacy {
    82
            AccessList[] accessList;
    83
            uint256 chainId;
    84
            bytes data;
    85
            address from;
    86
            uint256 gas;
    87
            uint256 gasPrice;
    88
            bytes32 hash;
    89
            uint256 nonce;
    90
            bytes1 opcode;
    91
            bytes32 r;
    92
            bytes32 s;
    93
            uint256 txType;
    94
            address to;
    95
            uint8 v;
    96
            uint256 value;
    97
        }
    98
    99
        struct AccessList {
    100
            address accessAddress;
    101
            bytes32[] storageKeys;
    102
        }
    103
    104
        // Data structures to parse Receipt objects from the broadcast artifact.
    105
        // The Raw structs is what is parsed from the JSON
    106
        // and then converted to the one that is used by the user for better UX.
    107
    108
        struct RawReceipt {
    109
            bytes32 blockHash;
    110
            bytes blockNumber;
    111
            address contractAddress;
    112
            bytes cumulativeGasUsed;
    113
            bytes effectiveGasPrice;
    114
            address from;
    115
            bytes gasUsed;
    116
            RawReceiptLog[] logs;
    117
            bytes logsBloom;
    118
            bytes status;
    119
            address to;
    120
            bytes32 transactionHash;
    121
            bytes transactionIndex;
    122
        }
    123
    124
        struct Receipt {
    125
            bytes32 blockHash;
    126
            uint256 blockNumber;
    127
            address contractAddress;
    128
            uint256 cumulativeGasUsed;
    129
            uint256 effectiveGasPrice;
    130
            address from;
    131
            uint256 gasUsed;
    132
            ReceiptLog[] logs;
    133
            bytes logsBloom;
    134
            uint256 status;
    135
            address to;
    136
            bytes32 transactionHash;
    137
            uint256 transactionIndex;
    138
        }
    139
    140
        // Data structures to parse the entire broadcast artifact, assuming the
    141
        // transactions conform to EIP1559.
    142
    143
        struct EIP1559ScriptArtifact {
    144
            string[] libraries;
    145
            string path;
    146
            string[] pending;
    147
            Receipt[] receipts;
    148
            uint256 timestamp;
    149
            Tx1559[] transactions;
    150
            TxReturn[] txReturns;
    151
        }
    152
    153
        struct RawEIP1559ScriptArtifact {
    154
            string[] libraries;
    155
            string path;
    156
            string[] pending;
    157
            RawReceipt[] receipts;
    158
            TxReturn[] txReturns;
    159
            uint256 timestamp;
    160
            RawTx1559[] transactions;
    161
        }
    162
    163
        struct RawReceiptLog {
    164
            // json value = address
    165
            address logAddress;
    166
            bytes32 blockHash;
    167
            bytes blockNumber;
    168
            bytes data;
    169
            bytes logIndex;
    170
            bool removed;
    171
            bytes32[] topics;
    172
            bytes32 transactionHash;
    173
            bytes transactionIndex;
    174
            bytes transactionLogIndex;
    175
        }
    176
    177
        struct ReceiptLog {
    178
            // json value = address
    179
            address logAddress;
    180
            bytes32 blockHash;
    181
            uint256 blockNumber;
    182
            bytes data;
    183
            uint256 logIndex;
    184
            bytes32[] topics;
    185
            uint256 transactionIndex;
    186
            uint256 transactionLogIndex;
    187
            bool removed;
    188
        }
    189
    190
        struct TxReturn {
    191
            string internalType;
    192
            string value;
    193
        }
    194
    195
        struct Account {
    196
            address addr;
    197
            uint256 key;
    198
        }
    199
    200
        enum AddressType {
    201
            Payable,
    202
            NonPayable,
    203
            ZeroAddress,
    204
            Precompile,
    205
            ForgeAddress
    206
        }
    207
    208
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    209
        function assumeNotBlacklisted(address token, address addr) internal view virtual {
    210
            // Nothing to check if `token` is not a contract.
    211
            uint256 tokenCodeSize;
    212
            assembly {
    213
                tokenCodeSize := extcodesize(token)
    214
            }
    215
            require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
    216
    217
            bool success;
    218
            bytes memory returnData;
    219
    220
            // 4-byte selector for `isBlacklisted(address)`, used by USDC.
    221
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
    222
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    223
    224
            // 4-byte selector for `isBlackListed(address)`, used by USDT.
    225
            (success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
    226
            vm.assume(!success || abi.decode(returnData, (bool)) == false);
    227
        }
    228
    229
        // Checks that `addr` is not blacklisted by token contracts that have a blacklist.
    230
        // This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for
    231
        // backwards compatibility, since this name was used in the original PR which already has
    232
        // a release. This function can be removed in a future release once we want a breaking change.
    233
        function assumeNoBlacklisted(address token, address addr) internal view virtual {
    234
            assumeNotBlacklisted(token, addr);
    235
        }
    236
    237
        function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
    238
            if (addressType == AddressType.Payable) {
    239
                assumeNotPayable(addr);
    240
            } else if (addressType == AddressType.NonPayable) {
    241
                assumePayable(addr);
    242
            } else if (addressType == AddressType.ZeroAddress) {
    243
                assumeNotZeroAddress(addr);
    244
            } else if (addressType == AddressType.Precompile) {
    245
                assumeNotPrecompile(addr);
    246
            } else if (addressType == AddressType.ForgeAddress) {
    247
                assumeNotForgeAddress(addr);
    248
            }
    249
        }
    250
    251
        function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
    252
            assumeAddressIsNot(addr, addressType1);
    253
            assumeAddressIsNot(addr, addressType2);
    254
        }
    255
    256
        function assumeAddressIsNot(
    257
            address addr,
    258
            AddressType addressType1,
    259
            AddressType addressType2,
    260
            AddressType addressType3
    261
        ) internal virtual {
    262
            assumeAddressIsNot(addr, addressType1);
    263
            assumeAddressIsNot(addr, addressType2);
    264
            assumeAddressIsNot(addr, addressType3);
    265
        }
    266
    267
        function assumeAddressIsNot(
    268
            address addr,
    269
            AddressType addressType1,
    270
            AddressType addressType2,
    271
            AddressType addressType3,
    272
            AddressType addressType4
    273
        ) internal virtual {
    274
            assumeAddressIsNot(addr, addressType1);
    275
            assumeAddressIsNot(addr, addressType2);
    276
            assumeAddressIsNot(addr, addressType3);
    277
            assumeAddressIsNot(addr, addressType4);
    278
        }
    279
    280
        // This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
    281
        // `addr` and checking the `success` return value.
    282
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    283
        // implemented by `addr`, which should be taken into account when this function is used.
    284
        function _isPayable(address addr) private returns (bool) {
    285
            require(
    286
                addr.balance < UINT256_MAX,
    287
                "StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
    288
            );
    289
            uint256 origBalanceTest = address(this).balance;
    290
            uint256 origBalanceAddr = address(addr).balance;
    291
    292
            vm.deal(address(this), 1);
    293
            (bool success,) = payable(addr).call{value: 1}("");
    294
    295
            // reset balances
    296
            vm.deal(address(this), origBalanceTest);
    297
            vm.deal(addr, origBalanceAddr);
    298
    299
            return success;
    300
        }
    301
    302
        // NOTE: This function may result in state changes depending on the fallback/receive logic
    303
        // implemented by `addr`, which should be taken into account when this function is used. See the
    304
        // `_isPayable` method for more information.
    305
        function assumePayable(address addr) internal virtual {
    306
            vm.assume(_isPayable(addr));
    307
        }
    308
    309
        function assumeNotPayable(address addr) internal virtual {
    310
            vm.assume(!_isPayable(addr));
    311
        }
    312
    313
        function assumeNotZeroAddress(address addr) internal pure virtual {
    314
            vm.assume(addr != address(0));
    315
        }
    316
    317
        function assumeNotPrecompile(address addr) internal pure virtual {
    318
            assumeNotPrecompile(addr, _pureChainId());
    319
        }
    320
    321
        function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
    322
            // Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
    323
            // address), but the same rationale for excluding them applies so we include those too.
    324
    325
            // These are reserved by Ethereum and may be on all EVM-compatible chains.
    326
            vm.assume(addr < address(0x1) || addr > address(0xff));
    327
    328
            // forgefmt: disable-start
    329
            if (chainId == 10 || chainId == 420 || chainId == 11155420) {
    330
                // https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
    331
                vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
    332
            } else if (chainId == 42161 || chainId == 421613) {
    333
                // https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
    334
                vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
    335
            } else if (chainId == 43114 || chainId == 43113) {
    336
                // https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
    337
                vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
    338
                vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
    339
                vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
    340
            }
    341
            // forgefmt: disable-end
    342
        }
    343
    344
        function assumeNotForgeAddress(address addr) internal pure virtual {
    345
            // vm, console, and Create2Deployer addresses
    346
            vm.assume(
    347
                addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
    348
                    && addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
    349
            );
    350
        }
    351
    352
        function assumeUnusedAddress(address addr) internal view virtual {
    353
            uint256 size;
    354
            assembly {
    355
                size := extcodesize(addr)
    356
            }
    357
            vm.assume(size == 0);
    358
    359
            assumeNotPrecompile(addr);
    360
            assumeNotZeroAddress(addr);
    361
            assumeNotForgeAddress(addr);
    362
        }
    363
    364
        function readEIP1559ScriptArtifact(string memory path)
    365
            internal
    366
            view
    367
            virtual
    368
            returns (EIP1559ScriptArtifact memory)
    369
        {
    370
            string memory data = vm.readFile(path);
    371
            bytes memory parsedData = vm.parseJson(data);
    372
            RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
    373
            EIP1559ScriptArtifact memory artifact;
    374
            artifact.libraries = rawArtifact.libraries;
    375
            artifact.path = rawArtifact.path;
    376
            artifact.timestamp = rawArtifact.timestamp;
    377
            artifact.pending = rawArtifact.pending;
    378
            artifact.txReturns = rawArtifact.txReturns;
    379
            artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
    380
            artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
    381
            return artifact;
    382
        }
    383
    384
        function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
    385
            Tx1559[] memory txs = new Tx1559[](rawTxs.length);
    386
            for (uint256 i; i < rawTxs.length; i++) {
    387
                txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
    388
            }
    389
            return txs;
    390
        }
    391
    392
        function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
    393
            Tx1559 memory transaction;
    394
            transaction.arguments = rawTx.arguments;
    395
            transaction.contractName = rawTx.contractName;
    396
            transaction.functionSig = rawTx.functionSig;
    397
            transaction.hash = rawTx.hash;
    398
            transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
    399
            transaction.opcode = rawTx.opcode;
    400
            return transaction;
    401
        }
    402
    403
        function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
    404
            internal
    405
            pure
    406
            virtual
    407
            returns (Tx1559Detail memory)
    408
        {
    409
            Tx1559Detail memory txDetail;
    410
            txDetail.data = rawDetail.data;
    411
            txDetail.from = rawDetail.from;
    412
            txDetail.to = rawDetail.to;
    413
            txDetail.nonce = _bytesToUint(rawDetail.nonce);
    414
            txDetail.txType = _bytesToUint(rawDetail.txType);
    415
            txDetail.value = _bytesToUint(rawDetail.value);
    416
            txDetail.gas = _bytesToUint(rawDetail.gas);
    417
            txDetail.accessList = rawDetail.accessList;
    418
            return txDetail;
    419
        }
    420
    421
        function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
    422
            string memory deployData = vm.readFile(path);
    423
            bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
    424
            RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
    425
            return rawToConvertedEIPTx1559s(rawTxs);
    426
        }
    427
    428
        function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
    429
            string memory deployData = vm.readFile(path);
    430
            string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
    431
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    432
            RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
    433
            return rawToConvertedEIPTx1559(rawTx);
    434
        }
    435
    436
        // Analogous to readTransactions, but for receipts.
    437
        function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
    438
            string memory deployData = vm.readFile(path);
    439
            bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
    440
            RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
    441
            return rawToConvertedReceipts(rawReceipts);
    442
        }
    443
    444
        function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
    445
            string memory deployData = vm.readFile(path);
    446
            string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
    447
            bytes memory parsedDeployData = vm.parseJson(deployData, key);
    448
            RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
    449
            return rawToConvertedReceipt(rawReceipt);
    450
        }
    451
    452
        function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
    453
            Receipt[] memory receipts = new Receipt[](rawReceipts.length);
    454
            for (uint256 i; i < rawReceipts.length; i++) {
    455
                receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
    456
            }
    457
            return receipts;
    458
        }
    459
    460
        function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
    461
            Receipt memory receipt;
    462
            receipt.blockHash = rawReceipt.blockHash;
    463
            receipt.to = rawReceipt.to;
    464
            receipt.from = rawReceipt.from;
    465
            receipt.contractAddress = rawReceipt.contractAddress;
    466
            receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
    467
            receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
    468
            receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
    469
            receipt.status = _bytesToUint(rawReceipt.status);
    470
            receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
    471
            receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
    472
            receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
    473
            receipt.logsBloom = rawReceipt.logsBloom;
    474
            receipt.transactionHash = rawReceipt.transactionHash;
    475
            return receipt;
    476
        }
    477
    478
        function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
    479
            internal
    480
            pure
    481
            virtual
    482
            returns (ReceiptLog[] memory)
    483
        {
    484
            ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
    485
            for (uint256 i; i < rawLogs.length; i++) {
    486
                logs[i].logAddress = rawLogs[i].logAddress;
    487
                logs[i].blockHash = rawLogs[i].blockHash;
    488
                logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
    489
                logs[i].data = rawLogs[i].data;
    490
                logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
    491
                logs[i].topics = rawLogs[i].topics;
    492
                logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
    493
                logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
    494
                logs[i].removed = rawLogs[i].removed;
    495
            }
    496
            return logs;
    497
        }
    498
    499
        // Deploy a contract by fetching the contract bytecode from
    500
        // the artifacts directory
    501
        // e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`
    502
        function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
    503
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    504
            /// @solidity memory-safe-assembly
    505
            assembly {
    506
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    507
            }
    508
    509
            require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
    510
        }
    511
    512
        function deployCode(string memory what) internal virtual returns (address addr) {
    513
            bytes memory bytecode = vm.getCode(what);
    514
            /// @solidity memory-safe-assembly
    515
            assembly {
    516
                addr := create(0, add(bytecode, 0x20), mload(bytecode))
    517
            }
    518
    519
            require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
    520
        }
    521
    522
        /// @dev deploy contract with value on construction
    523
        function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
    524
            bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
    525
            /// @solidity memory-safe-assembly
    526
            assembly {
    527
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    528
            }
    529
    530
            require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
    531
        }
    532
    533
        function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
    534
            bytes memory bytecode = vm.getCode(what);
    535
            /// @solidity memory-safe-assembly
    536
            assembly {
    537
                addr := create(val, add(bytecode, 0x20), mload(bytecode))
    538
            }
    539
    540
            require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
    541
        }
    542
    543
        // creates a labeled address and the corresponding private key
    544
        function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
    545
            privateKey = uint256(keccak256(abi.encodePacked(name)));
    546
            addr = vm.addr(privateKey);
    547
            vm.label(addr, name);
    548
        }
    549
    550
        // creates a labeled address
    551
        function makeAddr(string memory name) internal virtual returns (address addr) {
    552
            (addr,) = makeAddrAndKey(name);
    553
        }
    554
    555
        // Destroys an account immediately, sending the balance to beneficiary.
    556
        // Destroying means: balance will be zero, code will be empty, and nonce will be 0
    557
        // This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce
    558
        // only after tx ends, this will run immediately.
    559
        function destroyAccount(address who, address beneficiary) internal virtual {
    560
            uint256 currBalance = who.balance;
    561
            vm.etch(who, abi.encode());
    562
            vm.deal(who, 0);
    563
            vm.resetNonce(who);
    564
    565
            uint256 beneficiaryBalance = beneficiary.balance;
    566
            vm.deal(beneficiary, currBalance + beneficiaryBalance);
    567
        }
    568
    569
        // creates a struct containing both a labeled address and the corresponding private key
    570
        function makeAccount(string memory name) internal virtual returns (Account memory account) {
    571
            (account.addr, account.key) = makeAddrAndKey(name);
    572
        }
    573
    574
        function deriveRememberKey(string memory mnemonic, uint32 index)
    575
            internal
    576
            virtual
    577
            returns (address who, uint256 privateKey)
    578
        {
    579
            privateKey = vm.deriveKey(mnemonic, index);
    580
            who = vm.rememberKey(privateKey);
    581
        }
    582
    583
        function _bytesToUint(bytes memory b) private pure returns (uint256) {
    584
            require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
    585
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    586
        }
    587
    588
        function isFork() internal view virtual returns (bool status) {
    589
            try vm.activeFork() {
    590
                status = true;
    591
            } catch (bytes memory) {}
    592
        }
    593
    594
        modifier skipWhenForking() {
    595
            if (!isFork()) {
    596
                _;
    597
            }
    598
        }
    599
    600
        modifier skipWhenNotForking() {
    601
            if (isFork()) {
    602
                _;
    603
            }
    604
        }
    605
    606
        modifier noGasMetering() {
    607
            vm.pauseGasMetering();
    608
            // To prevent turning gas monitoring back on with nested functions that use this modifier,
    609
            // we check if gasMetering started in the off position. If it did, we don't want to turn
    610
            // it back on until we exit the top level function that used the modifier
    611
            //
    612
            // i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
    613
            // funcA will have `gasStartedOff` as false, funcB will have it as true,
    614
            // so we only turn metering back on at the end of the funcA
    615
            bool gasStartedOff = gasMeteringOff;
    616
            gasMeteringOff = true;
    617
    618
            _;
    619
    620
            // if gas metering was on when this modifier was called, turn it back on at the end
    621
            if (!gasStartedOff) {
    622
                gasMeteringOff = false;
    623
                vm.resumeGasMetering();
    624
            }
    625
        }
    626
    627
        // We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
    628
        // compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
    629
        // can't simply access the chain ID in a normal view or pure function because the solc View Pure
    630
        // Checker changed `chainid` from pure to view in 0.8.0.
    631
        function _viewChainId() private view returns (uint256 chainId) {
    632
            // Assembly required since `block.chainid` was introduced in 0.8.0.
    633
            assembly {
    634
                chainId := chainid()
    635
            }
    636
    637
            address(this); // Silence warnings in older Solc versions.
    638
        }
    639
    640
        function _pureChainId() private pure returns (uint256 chainId) {
    641
            function() internal view returns (uint256) fnIn = _viewChainId;
    642
            function() internal pure returns (uint256) pureChainId;
    643
            assembly {
    644
                pureChainId := fnIn
    645
            }
    646
            chainId = pureChainId();
    647
        }
    648
    }
    649
    650
    // Wrappers around cheatcodes to avoid footguns
    651
    abstract contract StdCheats is StdCheatsSafe {
    652
        using stdStorage for StdStorage;
    653
    654
        StdStorage private stdstore;
    655
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    656
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    657
    658
        // Skip forward or rewind time by the specified number of seconds
    659
        function skip(uint256 time) internal virtual {
    660
            vm.warp(vm.getBlockTimestamp() + time);
    661
        }
    662
    663
        function rewind(uint256 time) internal virtual {
    664
            vm.warp(vm.getBlockTimestamp() - time);
    665
        }
    666
    667
        // Setup a prank from an address that has some ether
    668
        function hoax(address msgSender) internal virtual {
    669
            vm.deal(msgSender, 1 << 128);
    670
            vm.prank(msgSender);
    671
        }
    672
    673
        function hoax(address msgSender, uint256 give) internal virtual {
    674
            vm.deal(msgSender, give);
    675
            vm.prank(msgSender);
    676
        }
    677
    678
        function hoax(address msgSender, address origin) internal virtual {
    679
            vm.deal(msgSender, 1 << 128);
    680
            vm.prank(msgSender, origin);
    681
        }
    682
    683
        function hoax(address msgSender, address origin, uint256 give) internal virtual {
    684
            vm.deal(msgSender, give);
    685
            vm.prank(msgSender, origin);
    686
        }
    687
    688
        // Start perpetual prank from an address that has some ether
    689
        function startHoax(address msgSender) internal virtual {
    690
            vm.deal(msgSender, 1 << 128);
    691
            vm.startPrank(msgSender);
    692
        }
    693
    694
        function startHoax(address msgSender, uint256 give) internal virtual {
    695
            vm.deal(msgSender, give);
    696
            vm.startPrank(msgSender);
    697
        }
    698
    699
        // Start perpetual prank from an address that has some ether
    700
        // tx.origin is set to the origin parameter
    701
        function startHoax(address msgSender, address origin) internal virtual {
    702
            vm.deal(msgSender, 1 << 128);
    703
            vm.startPrank(msgSender, origin);
    704
        }
    705
    706
        function startHoax(address msgSender, address origin, uint256 give) internal virtual {
    707
            vm.deal(msgSender, give);
    708
            vm.startPrank(msgSender, origin);
    709
        }
    710
    711
        function changePrank(address msgSender) internal virtual {
    712
            console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
    713
            vm.stopPrank();
    714
            vm.startPrank(msgSender);
    715
        }
    716
    717
        function changePrank(address msgSender, address txOrigin) internal virtual {
    718
            console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
    719
            vm.stopPrank();
    720
            vm.startPrank(msgSender, txOrigin);
    721
        }
    722
    723
        // The same as Vm's `deal`
    724
        // Use the alternative signature for ERC20 tokens
    725
        function deal(address to, uint256 give) internal virtual {
    726
            vm.deal(to, give);
    727
        }
    728
    729
        // Set the balance of an account for any ERC20 token
    730
        // Use the alternative signature to update `totalSupply`
    731
        function deal(address token, address to, uint256 give) internal virtual {
    732
            deal(token, to, give, false);
    733
        }
    734
    735
        // Set the balance of an account for any ERC1155 token
    736
        // Use the alternative signature to update `totalSupply`
    737
        function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
    738
            dealERC1155(token, to, id, give, false);
    739
        }
    740
    741
        function deal(address token, address to, uint256 give, bool adjust) internal virtual {
    742
            // get current balance
    743
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    744
            uint256 prevBal = abi.decode(balData, (uint256));
    745
    746
            // update balance
    747
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
    748
    749
            // update total supply
    750
            if (adjust) {
    751
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
    752
                uint256 totSup = abi.decode(totSupData, (uint256));
    753
                if (give < prevBal) {
    754
                    totSup -= (prevBal - give);
    755
                } else {
    756
                    totSup += (give - prevBal);
    757
                }
    758
                stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
    759
            }
    760
        }
    761
    762
        function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
    763
            // get current balance
    764
            (, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
    765
            uint256 prevBal = abi.decode(balData, (uint256));
    766
    767
            // update balance
    768
            stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
    769
    770
            // update total supply
    771
            if (adjust) {
    772
                (, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
    773
                require(
    774
                    totSupData.length != 0,
    775
                    "StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply."
    776
                );
    777
                uint256 totSup = abi.decode(totSupData, (uint256));
    778
                if (give < prevBal) {
    779
                    totSup -= (prevBal - give);
    780
                } else {
    781
                    totSup += (give - prevBal);
    782
                }
    783
                stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
    784
            }
    785
        }
    786
    787
        function dealERC721(address token, address to, uint256 id) internal virtual {
    788
            // check if token id is already minted and the actual owner.
    789
            (bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
    790
            require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted.");
    791
    792
            // get owner current balance
    793
            (, bytes memory fromBalData) =
    794
                token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
    795
            uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
    796
    797
            // get new user current balance
    798
            (, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
    799
            uint256 toPrevBal = abi.decode(toBalData, (uint256));
    800
    801
            // update balances
    802
            stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
    803
            stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
    804
    805
            // update owner
    806
            stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
    807
        }
    808
    809
        function deployCodeTo(string memory what, address where) internal virtual {
    810
            deployCodeTo(what, "", 0, where);
    811
        }
    812
    813
        function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
    814
            deployCodeTo(what, args, 0, where);
    815
        }
    816
    817
        function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
    818
            bytes memory creationCode = vm.getCode(what);
    819
            vm.etch(where, abi.encodePacked(creationCode, args));
    820
            (bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
    821
            require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
    822
            vm.etch(where, runtimeBytecode);
    823
        }
    824
    825
        // Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
    826
        function console2_log_StdCheats(string memory p0) private view {
    827
            (bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
    828
            status;
    829
        }
    830
    }
    831
    0.0% lib/forge-std/src/StdConstants.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    import {IMulticall3} from "./interfaces/IMulticall3.sol";
    5
    import {Vm} from "./Vm.sol";
    6
    7
    library StdConstants {
    8
        /// @dev Cheat code address.
    9
        /// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
    10
        Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
    11
        /// @dev console.sol and console2.sol work by executing a staticcall to this address.
    12
        /// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
    13
        address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
    14
        /// @dev Used when deploying with create2.
    15
        /// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
    16
        address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    17
        /// @dev The default address for tx.origin and msg.sender.
    18
        /// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
    19
        address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
    20
        /// @dev The address of the first contract `CREATE`d by a running test contract.
    21
        /// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
    22
        /// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
    23
        address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
    24
        /// @dev Deterministic deployment address of the Multicall3 contract.
    25
        /// Taken from https://www.multicall3.com.
    26
        IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
    27
        /// @dev The order of the secp256k1 curve.
    28
        uint256 internal constant SECP256K1_ORDER =
    29
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    30
    }
    31
    0.0% lib/forge-std/src/StdError.sol
    Lines covered: 0 / 10 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
    3
    pragma solidity >=0.6.2 <0.9.0;
    4
    5
    library stdError {
    6
        bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
    7
        bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
    8
        bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
    9
        bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
    10
        bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
    11
        bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
    12
        bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
    13
        bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
    14
        bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
    15
    }
    16
    100.0% lib/forge-std/src/StdInvariant.sol
    Lines covered: 12 / 12 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    abstract contract StdInvariant {
    7
        struct FuzzSelector {
    8
            address addr;
    9
            bytes4[] selectors;
    10
        }
    11
    12
        struct FuzzArtifactSelector {
    13
            string artifact;
    14
            bytes4[] selectors;
    15
        }
    16
    17
        struct FuzzInterface {
    18
            address addr;
    19
            string[] artifacts;
    20
        }
    21
    22
        address[] private _excludedContracts;
    23
        address[] private _excludedSenders;
    24
        address[] private _targetedContracts;
    25
        address[] private _targetedSenders;
    26
    27
        string[] private _excludedArtifacts;
    28
        string[] private _targetedArtifacts;
    29
    30
        FuzzArtifactSelector[] private _targetedArtifactSelectors;
    31
    32
        FuzzSelector[] private _excludedSelectors;
    33
        FuzzSelector[] private _targetedSelectors;
    34
    35
        FuzzInterface[] private _targetedInterfaces;
    36
    37
        // Functions for users:
    38
        // These are intended to be called in tests.
    39
    40
        function excludeContract(address newExcludedContract_) internal {
    41
            _excludedContracts.push(newExcludedContract_);
    42
        }
    43
    44
        function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
    45
            _excludedSelectors.push(newExcludedSelector_);
    46
        }
    47
    48
        function excludeSender(address newExcludedSender_) internal {
    49
            _excludedSenders.push(newExcludedSender_);
    50
        }
    51
    52
        function excludeArtifact(string memory newExcludedArtifact_) internal {
    53
            _excludedArtifacts.push(newExcludedArtifact_);
    54
        }
    55
    56
        function targetArtifact(string memory newTargetedArtifact_) internal {
    57
            _targetedArtifacts.push(newTargetedArtifact_);
    58
        }
    59
    60
        function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
    61
            _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
    62
        }
    63
    64
        function targetContract(address newTargetedContract_) internal {
    65
            _targetedContracts.push(newTargetedContract_);
    66
        }
    67
    68
        function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
    69
            _targetedSelectors.push(newTargetedSelector_);
    70
        }
    71
    72
        function targetSender(address newTargetedSender_) internal {
    73
            _targetedSenders.push(newTargetedSender_);
    74
        }
    75
    76
        function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
    77
            _targetedInterfaces.push(newTargetedInterface_);
    78
        }
    79
    80
        // Functions for forge:
    81
        // These are called by forge to run invariant tests and don't need to be called in tests.
    82
    83
        function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
    84
            excludedArtifacts_ = _excludedArtifacts;
    85
        }
    86
    87
        function excludeContracts() public view returns (address[] memory excludedContracts_) {
    88
            excludedContracts_ = _excludedContracts;
    89
        }
    90
    91
        function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
    92
            excludedSelectors_ = _excludedSelectors;
    93
        }
    94
    95
        function excludeSenders() public view returns (address[] memory excludedSenders_) {
    96
            excludedSenders_ = _excludedSenders;
    97
        }
    98
    99
        function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
    100
            targetedArtifacts_ = _targetedArtifacts;
    101
        }
    102
    103
        function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
    104
            targetedArtifactSelectors_ = _targetedArtifactSelectors;
    105
        }
    106
    107
        function targetContracts() public view returns (address[] memory targetedContracts_) {
    108
            targetedContracts_ = _targetedContracts;
    109
        }
    110
    111
        function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
    112
            targetedSelectors_ = _targetedSelectors;
    113
        }
    114
    115
        function targetSenders() public view returns (address[] memory targetedSenders_) {
    116
            targetedSenders_ = _targetedSenders;
    117
        }
    118
    119
        function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
    120
            targetedInterfaces_ = _targetedInterfaces;
    121
        }
    122
    }
    123
    0.0% lib/forge-std/src/StdJson.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    import {VmSafe} from "./Vm.sol";
    7
    8
    // Helpers for parsing and writing JSON files
    9
    // To parse:
    10
    // ```
    11
    // using stdJson for string;
    12
    // string memory json = vm.readFile("<some_path>");
    13
    // json.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdJson for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    25
    library stdJson {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    28
        function keyExists(string memory json, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsJson(json, key);
    30
        }
    31
    32
        function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseJson(json, key);
    34
        }
    35
    36
        function readUint(string memory json, string memory key) internal pure returns (uint256) {
    37
            return vm.parseJsonUint(json, key);
    38
        }
    39
    40
        function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseJsonUintArray(json, key);
    42
        }
    43
    44
        function readInt(string memory json, string memory key) internal pure returns (int256) {
    45
            return vm.parseJsonInt(json, key);
    46
        }
    47
    48
        function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseJsonIntArray(json, key);
    50
        }
    51
    52
        function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseJsonBytes32(json, key);
    54
        }
    55
    56
        function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseJsonBytes32Array(json, key);
    58
        }
    59
    60
        function readString(string memory json, string memory key) internal pure returns (string memory) {
    61
            return vm.parseJsonString(json, key);
    62
        }
    63
    64
        function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseJsonStringArray(json, key);
    66
        }
    67
    68
        function readAddress(string memory json, string memory key) internal pure returns (address) {
    69
            return vm.parseJsonAddress(json, key);
    70
        }
    71
    72
        function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseJsonAddressArray(json, key);
    74
        }
    75
    76
        function readBool(string memory json, string memory key) internal pure returns (bool) {
    77
            return vm.parseJsonBool(json, key);
    78
        }
    79
    80
        function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseJsonBoolArray(json, key);
    82
        }
    83
    84
        function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseJsonBytes(json, key);
    86
        }
    87
    88
        function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseJsonBytesArray(json, key);
    90
        }
    91
    92
        function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(json, key) ? readUint(json, key) : defaultValue;
    94
        }
    95
    96
        function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
    102
        }
    103
    104
        function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(json, key) ? readInt(json, key) : defaultValue;
    106
        }
    107
    108
        function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
    114
        }
    115
    116
        function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
    122
        }
    123
    124
        function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
    130
        }
    131
    132
        function readStringOr(string memory json, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(json, key) ? readString(json, key) : defaultValue;
    138
        }
    139
    140
        function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
    146
        }
    147
    148
        function readAddressOr(string memory json, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(json, key) ? readAddress(json, key) : defaultValue;
    154
        }
    155
    156
        function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
    162
        }
    163
    164
        function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(json, key) ? readBool(json, key) : defaultValue;
    166
        }
    167
    168
        function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
    174
        }
    175
    176
        function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(json, key) ? readBytes(json, key) : defaultValue;
    182
        }
    183
    184
        function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
    190
        }
    191
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) {
    201
            return vm.serializeBool(jsonKey, key, value);
    202
        }
    203
    204
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    205
            return vm.serializeUint(jsonKey, key, value);
    206
        }
    207
    208
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    209
            internal
    210
            returns (string memory)
    211
        {
    212
            return vm.serializeUint(jsonKey, key, value);
    213
        }
    214
    215
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    216
            return vm.serializeInt(jsonKey, key, value);
    217
        }
    218
    219
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    220
            internal
    221
            returns (string memory)
    222
        {
    223
            return vm.serializeInt(jsonKey, key, value);
    224
        }
    225
    226
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    227
            return vm.serializeAddress(jsonKey, key, value);
    228
        }
    229
    230
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    231
            internal
    232
            returns (string memory)
    233
        {
    234
            return vm.serializeAddress(jsonKey, key, value);
    235
        }
    236
    237
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    238
            return vm.serializeBytes32(jsonKey, key, value);
    239
        }
    240
    241
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    242
            internal
    243
            returns (string memory)
    244
        {
    245
            return vm.serializeBytes32(jsonKey, key, value);
    246
        }
    247
    248
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    249
            return vm.serializeBytes(jsonKey, key, value);
    250
        }
    251
    252
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    253
            internal
    254
            returns (string memory)
    255
        {
    256
            return vm.serializeBytes(jsonKey, key, value);
    257
        }
    258
    259
        function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) {
    260
            return vm.serializeString(jsonKey, key, value);
    261
        }
    262
    263
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    264
            internal
    265
            returns (string memory)
    266
        {
    267
            return vm.serializeString(jsonKey, key, value);
    268
        }
    269
    270
        function write(string memory jsonKey, string memory path) internal {
    271
            vm.writeJson(jsonKey, path);
    272
        }
    273
    274
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    275
            vm.writeJson(jsonKey, path, valueKey);
    276
        }
    277
    }
    278
    0.0% lib/forge-std/src/StdMath.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    library stdMath {
    5
        int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
    6
    7
        function abs(int256 a) internal pure returns (uint256) {
    8
            // Required or it will fail when `a = type(int256).min`
    9
            if (a == INT256_MIN) {
    10
                return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
    11
            }
    12
    13
            return uint256(a > 0 ? a : -a);
    14
        }
    15
    16
        function delta(uint256 a, uint256 b) internal pure returns (uint256) {
    17
            return a > b ? a - b : b - a;
    18
        }
    19
    20
        function delta(int256 a, int256 b) internal pure returns (uint256) {
    21
            // a and b are of the same sign
    22
            // this works thanks to two's complement, the left-most bit is the sign bit
    23
            if ((a ^ b) > -1) {
    24
                return delta(abs(a), abs(b));
    25
            }
    26
    27
            // a and b are of opposite signs
    28
            return abs(a) + abs(b);
    29
        }
    30
    31
        function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
    32
            // Prevent division by zero
    33
            require(b != 0, "stdMath percentDelta(uint256,uint256): Divisor is zero");
    34
            uint256 absDelta = delta(a, b);
    35
    36
            return absDelta * 1e18 / b;
    37
        }
    38
    39
        function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
    40
            uint256 absDelta = delta(a, b);
    41
            uint256 absB = abs(b);
    42
            // Prevent division by zero
    43
            require(absB != 0, "stdMath percentDelta(int256,int256): Divisor is zero");
    44
    45
            return absDelta * 1e18 / absB;
    46
        }
    47
    }
    48
    0.0% lib/forge-std/src/StdStorage.sol
    Lines covered: 0 / 2 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    import {Vm} from "./Vm.sol";
    5
    6
    struct FindData {
    7
        uint256 slot;
    8
        uint256 offsetLeft;
    9
        uint256 offsetRight;
    10
        bool found;
    11
    }
    12
    13
    struct StdStorage {
    14
        mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
    15
        bytes32[] _keys;
    16
        bytes4 _sig;
    17
        uint256 _depth;
    18
        address _target;
    19
        bytes32 _set;
    20
        bool _enable_packed_slots;
    21
        bytes _calldata;
    22
    }
    23
    24
    library stdStorageSafe {
    25
        event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
    26
        event WARNING_UninitedSlot(address who, uint256 slot);
    27
    28
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    29
        uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
    30
    31
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    32
            return bytes4(keccak256(bytes(sigStr)));
    33
        }
    34
    35
        function getCallParams(StdStorage storage self) internal view returns (bytes memory) {
    36
            if (self._calldata.length == 0) {
    37
                return flatten(self._keys);
    38
            } else {
    39
                return self._calldata;
    40
            }
    41
        }
    42
    43
        // Calls target contract with configured parameters
    44
        function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {
    45
            bytes memory cd = abi.encodePacked(self._sig, getCallParams(self));
    46
            (bool success, bytes memory rdat) = self._target.staticcall(cd);
    47
            bytes32 result = bytesToBytes32(rdat, 32 * self._depth);
    48
    49
            return (success, result);
    50
        }
    51
    52
        // Tries mutating slot value to determine if the targeted value is stored in it.
    53
        // If current value is 0, then we are setting slot value to type(uint256).max
    54
        // Otherwise, we set it to 0. That way, return value should always be affected.
    55
        function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {
    56
            bytes32 prevSlotValue = vm.load(self._target, slot);
    57
            (bool success, bytes32 prevReturnValue) = callTarget(self);
    58
    59
            bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);
    60
            vm.store(self._target, slot, testVal);
    61
    62
            (, bytes32 newReturnValue) = callTarget(self);
    63
    64
            vm.store(self._target, slot, prevSlotValue);
    65
    66
            return (success && (prevReturnValue != newReturnValue));
    67
        }
    68
    69
        // Tries setting one of the bits in slot to 1 until return value changes.
    70
        // Index of resulted bit is an offset packed slot has from left/right side
    71
        function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {
    72
            for (uint256 offset = 0; offset < 256; offset++) {
    73
                uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);
    74
                vm.store(self._target, slot, bytes32(valueToPut));
    75
    76
                (bool success, bytes32 data) = callTarget(self);
    77
    78
                if (success && (uint256(data) > 0)) {
    79
                    return (true, offset);
    80
                }
    81
            }
    82
            return (false, 0);
    83
        }
    84
    85
        function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {
    86
            bytes32 prevSlotValue = vm.load(self._target, slot);
    87
    88
            (bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);
    89
            (bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);
    90
    91
            // `findOffset` may mutate slot value, so we are setting it to initial value
    92
            vm.store(self._target, slot, prevSlotValue);
    93
            return (foundLeft && foundRight, offsetLeft, offsetRight);
    94
        }
    95
    96
        function find(StdStorage storage self) internal returns (FindData storage) {
    97
            return find(self, true);
    98
        }
    99
    100
        /// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
    101
        // slot complexity:
    102
        //  if flat, will be bytes32(uint256(uint));
    103
        //  if map, will be keccak256(abi.encode(key, uint(slot)));
    104
        //  if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
    105
        //  if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
    106
        function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {
    107
            address who = self._target;
    108
            bytes4 fsig = self._sig;
    109
            uint256 field_depth = self._depth;
    110
            bytes memory params = getCallParams(self);
    111
    112
            // calldata to test against
    113
            if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    114
                if (_clear) {
    115
                    clear(self);
    116
                }
    117
                return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    118
            }
    119
            vm.record();
    120
            (, bytes32 callResult) = callTarget(self);
    121
            (bytes32[] memory reads,) = vm.accesses(address(who));
    122
    123
            if (reads.length == 0) {
    124
                revert("stdStorage find(StdStorage): No storage use detected for target.");
    125
            } else {
    126
                for (uint256 i = reads.length; --i >= 0;) {
    127
                    bytes32 prev = vm.load(who, reads[i]);
    128
                    if (prev == bytes32(0)) {
    129
                        emit WARNING_UninitedSlot(who, uint256(reads[i]));
    130
                    }
    131
    132
                    if (!checkSlotMutatesCall(self, reads[i])) {
    133
                        continue;
    134
                    }
    135
    136
                    (uint256 offsetLeft, uint256 offsetRight) = (0, 0);
    137
    138
                    if (self._enable_packed_slots) {
    139
                        bool found;
    140
                        (found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);
    141
                        if (!found) {
    142
                            continue;
    143
                        }
    144
                    }
    145
    146
                    // Check that value between found offsets is equal to the current call result
    147
                    uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;
    148
    149
                    if (uint256(callResult) != curVal) {
    150
                        continue;
    151
                    }
    152
    153
                    emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));
    154
                    self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =
    155
                        FindData(uint256(reads[i]), offsetLeft, offsetRight, true);
    156
                    break;
    157
                }
    158
            }
    159
    160
            require(
    161
                self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,
    162
                "stdStorage find(StdStorage): Slot(s) not found."
    163
            );
    164
    165
            if (_clear) {
    166
                clear(self);
    167
            }
    168
            return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    169
        }
    170
    171
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    172
            self._target = _target;
    173
            return self;
    174
        }
    175
    176
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    177
            self._sig = _sig;
    178
            return self;
    179
        }
    180
    181
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    182
            self._sig = sigs(_sig);
    183
            return self;
    184
        }
    185
    186
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    187
            self._calldata = _calldata;
    188
            return self;
    189
        }
    190
    191
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    192
            self._keys.push(bytes32(uint256(uint160(who))));
    193
            return self;
    194
        }
    195
    196
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    197
            self._keys.push(bytes32(amt));
    198
            return self;
    199
        }
    200
    201
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    202
            self._keys.push(key);
    203
            return self;
    204
        }
    205
    206
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    207
            self._enable_packed_slots = true;
    208
            return self;
    209
        }
    210
    211
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    212
            self._depth = _depth;
    213
            return self;
    214
        }
    215
    216
        function read(StdStorage storage self) private returns (bytes memory) {
    217
            FindData storage data = find(self, false);
    218
            uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);
    219
            uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;
    220
            clear(self);
    221
            return abi.encode(value);
    222
        }
    223
    224
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    225
            return abi.decode(read(self), (bytes32));
    226
        }
    227
    228
        function read_bool(StdStorage storage self) internal returns (bool) {
    229
            int256 v = read_int(self);
    230
            if (v == 0) return false;
    231
            if (v == 1) return true;
    232
            revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
    233
        }
    234
    235
        function read_address(StdStorage storage self) internal returns (address) {
    236
            return abi.decode(read(self), (address));
    237
        }
    238
    239
        function read_uint(StdStorage storage self) internal returns (uint256) {
    240
            return abi.decode(read(self), (uint256));
    241
        }
    242
    243
        function read_int(StdStorage storage self) internal returns (int256) {
    244
            return abi.decode(read(self), (int256));
    245
        }
    246
    247
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    248
            address who = self._target;
    249
            uint256 field_depth = self._depth;
    250
            vm.startMappingRecording();
    251
            uint256 child = find(self, true).slot - field_depth;
    252
            (bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    253
            if (!found) {
    254
                revert(
    255
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    256
                );
    257
            }
    258
            return (uint256(parent_slot), key);
    259
        }
    260
    261
        function root(StdStorage storage self) internal returns (uint256) {
    262
            address who = self._target;
    263
            uint256 field_depth = self._depth;
    264
            vm.startMappingRecording();
    265
            uint256 child = find(self, true).slot - field_depth;
    266
            bool found;
    267
            bytes32 root_slot;
    268
            bytes32 parent_slot;
    269
            (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
    270
            if (!found) {
    271
                revert(
    272
                    "stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
    273
                );
    274
            }
    275
            while (found) {
    276
                root_slot = parent_slot;
    277
                (found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
    278
            }
    279
            return uint256(root_slot);
    280
        }
    281
    282
        function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
    283
            bytes32 out;
    284
    285
            uint256 max = b.length > 32 ? 32 : b.length;
    286
            for (uint256 i = 0; i < max; i++) {
    287
                out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
    288
            }
    289
            return out;
    290
        }
    291
    292
        function flatten(bytes32[] memory b) private pure returns (bytes memory) {
    293
            bytes memory result = new bytes(b.length * 32);
    294
            for (uint256 i = 0; i < b.length; i++) {
    295
                bytes32 k = b[i];
    296
                /// @solidity memory-safe-assembly
    297
                assembly {
    298
                    mstore(add(result, add(32, mul(32, i))), k)
    299
                }
    300
            }
    301
    302
            return result;
    303
        }
    304
    305
        function clear(StdStorage storage self) internal {
    306
            delete self._target;
    307
            delete self._sig;
    308
            delete self._keys;
    309
            delete self._depth;
    310
            delete self._enable_packed_slots;
    311
            delete self._calldata;
    312
        }
    313
    314
        // Returns mask which contains non-zero bits for values between `offsetLeft` and `offsetRight`
    315
        // (slotValue & mask) >> offsetRight will be the value of the given packed variable
    316
        function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {
    317
            // mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;
    318
            // using assembly because (1 << 256) causes overflow
    319
            assembly {
    320
                mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))
    321
            }
    322
        }
    323
    324
        // Returns slot value with updated packed variable.
    325
        function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
    326
            internal
    327
            pure
    328
            returns (bytes32 newValue)
    329
        {
    330
            return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));
    331
        }
    332
    }
    333
    334
    library stdStorage {
    335
        Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    336
    337
        function sigs(string memory sigStr) internal pure returns (bytes4) {
    338
            return stdStorageSafe.sigs(sigStr);
    339
        }
    340
    341
        function find(StdStorage storage self) internal returns (uint256) {
    342
            return find(self, true);
    343
        }
    344
    345
        function find(StdStorage storage self, bool _clear) internal returns (uint256) {
    346
            return stdStorageSafe.find(self, _clear).slot;
    347
        }
    348
    349
        function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
    350
            return stdStorageSafe.target(self, _target);
    351
        }
    352
    353
        function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
    354
            return stdStorageSafe.sig(self, _sig);
    355
        }
    356
    357
        function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
    358
            return stdStorageSafe.sig(self, _sig);
    359
        }
    360
    361
        function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
    362
            return stdStorageSafe.with_key(self, who);
    363
        }
    364
    365
        function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
    366
            return stdStorageSafe.with_key(self, amt);
    367
        }
    368
    369
        function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
    370
            return stdStorageSafe.with_key(self, key);
    371
        }
    372
    373
        function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
    374
            return stdStorageSafe.with_calldata(self, _calldata);
    375
        }
    376
    377
        function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
    378
            return stdStorageSafe.enable_packed_slots(self);
    379
        }
    380
    381
        function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
    382
            return stdStorageSafe.depth(self, _depth);
    383
        }
    384
    385
        function clear(StdStorage storage self) internal {
    386
            stdStorageSafe.clear(self);
    387
        }
    388
    389
        function checked_write(StdStorage storage self, address who) internal {
    390
            checked_write(self, bytes32(uint256(uint160(who))));
    391
        }
    392
    393
        function checked_write(StdStorage storage self, uint256 amt) internal {
    394
            checked_write(self, bytes32(amt));
    395
        }
    396
    397
        function checked_write_int(StdStorage storage self, int256 val) internal {
    398
            checked_write(self, bytes32(uint256(val)));
    399
        }
    400
    401
        function checked_write(StdStorage storage self, bool write) internal {
    402
            bytes32 t;
    403
            /// @solidity memory-safe-assembly
    404
            assembly {
    405
                t := write
    406
            }
    407
            checked_write(self, t);
    408
        }
    409
    410
        function checked_write(StdStorage storage self, bytes32 set) internal {
    411
            address who = self._target;
    412
            bytes4 fsig = self._sig;
    413
            uint256 field_depth = self._depth;
    414
            bytes memory params = stdStorageSafe.getCallParams(self);
    415
    416
            if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
    417
                find(self, false);
    418
            }
    419
            FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
    420
            if ((data.offsetLeft + data.offsetRight) > 0) {
    421
                uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));
    422
                require(
    423
                    uint256(set) < maxVal,
    424
                    string(
    425
                        abi.encodePacked(
    426
                            "stdStorage find(StdStorage): Packed slot. We can't fit value greater than ",
    427
                            vm.toString(maxVal)
    428
                        )
    429
                    )
    430
                );
    431
            }
    432
            bytes32 curVal = vm.load(who, bytes32(data.slot));
    433
            bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);
    434
    435
            vm.store(who, bytes32(data.slot), valToSet);
    436
    437
            (bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);
    438
    439
            if (!success || callResult != set) {
    440
                vm.store(who, bytes32(data.slot), curVal);
    441
                revert("stdStorage find(StdStorage): Failed to write value.");
    442
            }
    443
            clear(self);
    444
        }
    445
    446
        function read_bytes32(StdStorage storage self) internal returns (bytes32) {
    447
            return stdStorageSafe.read_bytes32(self);
    448
        }
    449
    450
        function read_bool(StdStorage storage self) internal returns (bool) {
    451
            return stdStorageSafe.read_bool(self);
    452
        }
    453
    454
        function read_address(StdStorage storage self) internal returns (address) {
    455
            return stdStorageSafe.read_address(self);
    456
        }
    457
    458
        function read_uint(StdStorage storage self) internal returns (uint256) {
    459
            return stdStorageSafe.read_uint(self);
    460
        }
    461
    462
        function read_int(StdStorage storage self) internal returns (int256) {
    463
            return stdStorageSafe.read_int(self);
    464
        }
    465
    466
        function parent(StdStorage storage self) internal returns (uint256, bytes32) {
    467
            return stdStorageSafe.parent(self);
    468
        }
    469
    470
        function root(StdStorage storage self) internal returns (uint256) {
    471
            return stdStorageSafe.root(self);
    472
        }
    473
    }
    474
    0.0% lib/forge-std/src/StdStyle.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    4
    import {VmSafe} from "./Vm.sol";
    5
    6
    library StdStyle {
    7
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    8
    9
        string constant RED = "\u001b[91m";
    10
        string constant GREEN = "\u001b[92m";
    11
        string constant YELLOW = "\u001b[93m";
    12
        string constant BLUE = "\u001b[94m";
    13
        string constant MAGENTA = "\u001b[95m";
    14
        string constant CYAN = "\u001b[96m";
    15
        string constant BOLD = "\u001b[1m";
    16
        string constant DIM = "\u001b[2m";
    17
        string constant ITALIC = "\u001b[3m";
    18
        string constant UNDERLINE = "\u001b[4m";
    19
        string constant INVERSE = "\u001b[7m";
    20
        string constant RESET = "\u001b[0m";
    21
    22
        function styleConcat(string memory style, string memory self) private pure returns (string memory) {
    23
            return string(abi.encodePacked(style, self, RESET));
    24
        }
    25
    26
        function red(string memory self) internal pure returns (string memory) {
    27
            return styleConcat(RED, self);
    28
        }
    29
    30
        function red(uint256 self) internal pure returns (string memory) {
    31
            return red(vm.toString(self));
    32
        }
    33
    34
        function red(int256 self) internal pure returns (string memory) {
    35
            return red(vm.toString(self));
    36
        }
    37
    38
        function red(address self) internal pure returns (string memory) {
    39
            return red(vm.toString(self));
    40
        }
    41
    42
        function red(bool self) internal pure returns (string memory) {
    43
            return red(vm.toString(self));
    44
        }
    45
    46
        function redBytes(bytes memory self) internal pure returns (string memory) {
    47
            return red(vm.toString(self));
    48
        }
    49
    50
        function redBytes32(bytes32 self) internal pure returns (string memory) {
    51
            return red(vm.toString(self));
    52
        }
    53
    54
        function green(string memory self) internal pure returns (string memory) {
    55
            return styleConcat(GREEN, self);
    56
        }
    57
    58
        function green(uint256 self) internal pure returns (string memory) {
    59
            return green(vm.toString(self));
    60
        }
    61
    62
        function green(int256 self) internal pure returns (string memory) {
    63
            return green(vm.toString(self));
    64
        }
    65
    66
        function green(address self) internal pure returns (string memory) {
    67
            return green(vm.toString(self));
    68
        }
    69
    70
        function green(bool self) internal pure returns (string memory) {
    71
            return green(vm.toString(self));
    72
        }
    73
    74
        function greenBytes(bytes memory self) internal pure returns (string memory) {
    75
            return green(vm.toString(self));
    76
        }
    77
    78
        function greenBytes32(bytes32 self) internal pure returns (string memory) {
    79
            return green(vm.toString(self));
    80
        }
    81
    82
        function yellow(string memory self) internal pure returns (string memory) {
    83
            return styleConcat(YELLOW, self);
    84
        }
    85
    86
        function yellow(uint256 self) internal pure returns (string memory) {
    87
            return yellow(vm.toString(self));
    88
        }
    89
    90
        function yellow(int256 self) internal pure returns (string memory) {
    91
            return yellow(vm.toString(self));
    92
        }
    93
    94
        function yellow(address self) internal pure returns (string memory) {
    95
            return yellow(vm.toString(self));
    96
        }
    97
    98
        function yellow(bool self) internal pure returns (string memory) {
    99
            return yellow(vm.toString(self));
    100
        }
    101
    102
        function yellowBytes(bytes memory self) internal pure returns (string memory) {
    103
            return yellow(vm.toString(self));
    104
        }
    105
    106
        function yellowBytes32(bytes32 self) internal pure returns (string memory) {
    107
            return yellow(vm.toString(self));
    108
        }
    109
    110
        function blue(string memory self) internal pure returns (string memory) {
    111
            return styleConcat(BLUE, self);
    112
        }
    113
    114
        function blue(uint256 self) internal pure returns (string memory) {
    115
            return blue(vm.toString(self));
    116
        }
    117
    118
        function blue(int256 self) internal pure returns (string memory) {
    119
            return blue(vm.toString(self));
    120
        }
    121
    122
        function blue(address self) internal pure returns (string memory) {
    123
            return blue(vm.toString(self));
    124
        }
    125
    126
        function blue(bool self) internal pure returns (string memory) {
    127
            return blue(vm.toString(self));
    128
        }
    129
    130
        function blueBytes(bytes memory self) internal pure returns (string memory) {
    131
            return blue(vm.toString(self));
    132
        }
    133
    134
        function blueBytes32(bytes32 self) internal pure returns (string memory) {
    135
            return blue(vm.toString(self));
    136
        }
    137
    138
        function magenta(string memory self) internal pure returns (string memory) {
    139
            return styleConcat(MAGENTA, self);
    140
        }
    141
    142
        function magenta(uint256 self) internal pure returns (string memory) {
    143
            return magenta(vm.toString(self));
    144
        }
    145
    146
        function magenta(int256 self) internal pure returns (string memory) {
    147
            return magenta(vm.toString(self));
    148
        }
    149
    150
        function magenta(address self) internal pure returns (string memory) {
    151
            return magenta(vm.toString(self));
    152
        }
    153
    154
        function magenta(bool self) internal pure returns (string memory) {
    155
            return magenta(vm.toString(self));
    156
        }
    157
    158
        function magentaBytes(bytes memory self) internal pure returns (string memory) {
    159
            return magenta(vm.toString(self));
    160
        }
    161
    162
        function magentaBytes32(bytes32 self) internal pure returns (string memory) {
    163
            return magenta(vm.toString(self));
    164
        }
    165
    166
        function cyan(string memory self) internal pure returns (string memory) {
    167
            return styleConcat(CYAN, self);
    168
        }
    169
    170
        function cyan(uint256 self) internal pure returns (string memory) {
    171
            return cyan(vm.toString(self));
    172
        }
    173
    174
        function cyan(int256 self) internal pure returns (string memory) {
    175
            return cyan(vm.toString(self));
    176
        }
    177
    178
        function cyan(address self) internal pure returns (string memory) {
    179
            return cyan(vm.toString(self));
    180
        }
    181
    182
        function cyan(bool self) internal pure returns (string memory) {
    183
            return cyan(vm.toString(self));
    184
        }
    185
    186
        function cyanBytes(bytes memory self) internal pure returns (string memory) {
    187
            return cyan(vm.toString(self));
    188
        }
    189
    190
        function cyanBytes32(bytes32 self) internal pure returns (string memory) {
    191
            return cyan(vm.toString(self));
    192
        }
    193
    194
        function bold(string memory self) internal pure returns (string memory) {
    195
            return styleConcat(BOLD, self);
    196
        }
    197
    198
        function bold(uint256 self) internal pure returns (string memory) {
    199
            return bold(vm.toString(self));
    200
        }
    201
    202
        function bold(int256 self) internal pure returns (string memory) {
    203
            return bold(vm.toString(self));
    204
        }
    205
    206
        function bold(address self) internal pure returns (string memory) {
    207
            return bold(vm.toString(self));
    208
        }
    209
    210
        function bold(bool self) internal pure returns (string memory) {
    211
            return bold(vm.toString(self));
    212
        }
    213
    214
        function boldBytes(bytes memory self) internal pure returns (string memory) {
    215
            return bold(vm.toString(self));
    216
        }
    217
    218
        function boldBytes32(bytes32 self) internal pure returns (string memory) {
    219
            return bold(vm.toString(self));
    220
        }
    221
    222
        function dim(string memory self) internal pure returns (string memory) {
    223
            return styleConcat(DIM, self);
    224
        }
    225
    226
        function dim(uint256 self) internal pure returns (string memory) {
    227
            return dim(vm.toString(self));
    228
        }
    229
    230
        function dim(int256 self) internal pure returns (string memory) {
    231
            return dim(vm.toString(self));
    232
        }
    233
    234
        function dim(address self) internal pure returns (string memory) {
    235
            return dim(vm.toString(self));
    236
        }
    237
    238
        function dim(bool self) internal pure returns (string memory) {
    239
            return dim(vm.toString(self));
    240
        }
    241
    242
        function dimBytes(bytes memory self) internal pure returns (string memory) {
    243
            return dim(vm.toString(self));
    244
        }
    245
    246
        function dimBytes32(bytes32 self) internal pure returns (string memory) {
    247
            return dim(vm.toString(self));
    248
        }
    249
    250
        function italic(string memory self) internal pure returns (string memory) {
    251
            return styleConcat(ITALIC, self);
    252
        }
    253
    254
        function italic(uint256 self) internal pure returns (string memory) {
    255
            return italic(vm.toString(self));
    256
        }
    257
    258
        function italic(int256 self) internal pure returns (string memory) {
    259
            return italic(vm.toString(self));
    260
        }
    261
    262
        function italic(address self) internal pure returns (string memory) {
    263
            return italic(vm.toString(self));
    264
        }
    265
    266
        function italic(bool self) internal pure returns (string memory) {
    267
            return italic(vm.toString(self));
    268
        }
    269
    270
        function italicBytes(bytes memory self) internal pure returns (string memory) {
    271
            return italic(vm.toString(self));
    272
        }
    273
    274
        function italicBytes32(bytes32 self) internal pure returns (string memory) {
    275
            return italic(vm.toString(self));
    276
        }
    277
    278
        function underline(string memory self) internal pure returns (string memory) {
    279
            return styleConcat(UNDERLINE, self);
    280
        }
    281
    282
        function underline(uint256 self) internal pure returns (string memory) {
    283
            return underline(vm.toString(self));
    284
        }
    285
    286
        function underline(int256 self) internal pure returns (string memory) {
    287
            return underline(vm.toString(self));
    288
        }
    289
    290
        function underline(address self) internal pure returns (string memory) {
    291
            return underline(vm.toString(self));
    292
        }
    293
    294
        function underline(bool self) internal pure returns (string memory) {
    295
            return underline(vm.toString(self));
    296
        }
    297
    298
        function underlineBytes(bytes memory self) internal pure returns (string memory) {
    299
            return underline(vm.toString(self));
    300
        }
    301
    302
        function underlineBytes32(bytes32 self) internal pure returns (string memory) {
    303
            return underline(vm.toString(self));
    304
        }
    305
    306
        function inverse(string memory self) internal pure returns (string memory) {
    307
            return styleConcat(INVERSE, self);
    308
        }
    309
    310
        function inverse(uint256 self) internal pure returns (string memory) {
    311
            return inverse(vm.toString(self));
    312
        }
    313
    314
        function inverse(int256 self) internal pure returns (string memory) {
    315
            return inverse(vm.toString(self));
    316
        }
    317
    318
        function inverse(address self) internal pure returns (string memory) {
    319
            return inverse(vm.toString(self));
    320
        }
    321
    322
        function inverse(bool self) internal pure returns (string memory) {
    323
            return inverse(vm.toString(self));
    324
        }
    325
    326
        function inverseBytes(bytes memory self) internal pure returns (string memory) {
    327
            return inverse(vm.toString(self));
    328
        }
    329
    330
        function inverseBytes32(bytes32 self) internal pure returns (string memory) {
    331
            return inverse(vm.toString(self));
    332
        }
    333
    }
    334
    0.0% lib/forge-std/src/StdToml.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.0 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    import {VmSafe} from "./Vm.sol";
    7
    8
    // Helpers for parsing and writing TOML files
    9
    // To parse:
    10
    // ```
    11
    // using stdToml for string;
    12
    // string memory toml = vm.readFile("<some_path>");
    13
    // toml.readUint("<json_path>");
    14
    // ```
    15
    // To write:
    16
    // ```
    17
    // using stdToml for string;
    18
    // string memory json = "json";
    19
    // json.serialize("a", uint256(123));
    20
    // string memory semiFinal = json.serialize("b", string("test"));
    21
    // string memory finalJson = json.serialize("c", semiFinal);
    22
    // finalJson.write("<some_path>");
    23
    // ```
    24
    25
    library stdToml {
    26
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    27
    28
        function keyExists(string memory toml, string memory key) internal view returns (bool) {
    29
            return vm.keyExistsToml(toml, key);
    30
        }
    31
    32
        function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) {
    33
            return vm.parseToml(toml, key);
    34
        }
    35
    36
        function readUint(string memory toml, string memory key) internal pure returns (uint256) {
    37
            return vm.parseTomlUint(toml, key);
    38
        }
    39
    40
        function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) {
    41
            return vm.parseTomlUintArray(toml, key);
    42
        }
    43
    44
        function readInt(string memory toml, string memory key) internal pure returns (int256) {
    45
            return vm.parseTomlInt(toml, key);
    46
        }
    47
    48
        function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) {
    49
            return vm.parseTomlIntArray(toml, key);
    50
        }
    51
    52
        function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) {
    53
            return vm.parseTomlBytes32(toml, key);
    54
        }
    55
    56
        function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) {
    57
            return vm.parseTomlBytes32Array(toml, key);
    58
        }
    59
    60
        function readString(string memory toml, string memory key) internal pure returns (string memory) {
    61
            return vm.parseTomlString(toml, key);
    62
        }
    63
    64
        function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) {
    65
            return vm.parseTomlStringArray(toml, key);
    66
        }
    67
    68
        function readAddress(string memory toml, string memory key) internal pure returns (address) {
    69
            return vm.parseTomlAddress(toml, key);
    70
        }
    71
    72
        function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) {
    73
            return vm.parseTomlAddressArray(toml, key);
    74
        }
    75
    76
        function readBool(string memory toml, string memory key) internal pure returns (bool) {
    77
            return vm.parseTomlBool(toml, key);
    78
        }
    79
    80
        function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) {
    81
            return vm.parseTomlBoolArray(toml, key);
    82
        }
    83
    84
        function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) {
    85
            return vm.parseTomlBytes(toml, key);
    86
        }
    87
    88
        function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) {
    89
            return vm.parseTomlBytesArray(toml, key);
    90
        }
    91
    92
        function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) {
    93
            return keyExists(toml, key) ? readUint(toml, key) : defaultValue;
    94
        }
    95
    96
        function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
    97
            internal
    98
            view
    99
            returns (uint256[] memory)
    100
        {
    101
            return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue;
    102
        }
    103
    104
        function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) {
    105
            return keyExists(toml, key) ? readInt(toml, key) : defaultValue;
    106
        }
    107
    108
        function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
    109
            internal
    110
            view
    111
            returns (int256[] memory)
    112
        {
    113
            return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue;
    114
        }
    115
    116
        function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue)
    117
            internal
    118
            view
    119
            returns (bytes32)
    120
        {
    121
            return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue;
    122
        }
    123
    124
        function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
    125
            internal
    126
            view
    127
            returns (bytes32[] memory)
    128
        {
    129
            return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue;
    130
        }
    131
    132
        function readStringOr(string memory toml, string memory key, string memory defaultValue)
    133
            internal
    134
            view
    135
            returns (string memory)
    136
        {
    137
            return keyExists(toml, key) ? readString(toml, key) : defaultValue;
    138
        }
    139
    140
        function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
    141
            internal
    142
            view
    143
            returns (string[] memory)
    144
        {
    145
            return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue;
    146
        }
    147
    148
        function readAddressOr(string memory toml, string memory key, address defaultValue)
    149
            internal
    150
            view
    151
            returns (address)
    152
        {
    153
            return keyExists(toml, key) ? readAddress(toml, key) : defaultValue;
    154
        }
    155
    156
        function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
    157
            internal
    158
            view
    159
            returns (address[] memory)
    160
        {
    161
            return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue;
    162
        }
    163
    164
        function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) {
    165
            return keyExists(toml, key) ? readBool(toml, key) : defaultValue;
    166
        }
    167
    168
        function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
    169
            internal
    170
            view
    171
            returns (bool[] memory)
    172
        {
    173
            return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue;
    174
        }
    175
    176
        function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
    177
            internal
    178
            view
    179
            returns (bytes memory)
    180
        {
    181
            return keyExists(toml, key) ? readBytes(toml, key) : defaultValue;
    182
        }
    183
    184
        function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
    185
            internal
    186
            view
    187
            returns (bytes[] memory)
    188
        {
    189
            return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue;
    190
        }
    191
    192
        function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
    193
            return vm.serializeJson(jsonKey, rootObject);
    194
        }
    195
    196
        function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
    197
            return vm.serializeBool(jsonKey, key, value);
    198
        }
    199
    200
        function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) {
    201
            return vm.serializeBool(jsonKey, key, value);
    202
        }
    203
    204
        function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
    205
            return vm.serializeUint(jsonKey, key, value);
    206
        }
    207
    208
        function serialize(string memory jsonKey, string memory key, uint256[] memory value)
    209
            internal
    210
            returns (string memory)
    211
        {
    212
            return vm.serializeUint(jsonKey, key, value);
    213
        }
    214
    215
        function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
    216
            return vm.serializeInt(jsonKey, key, value);
    217
        }
    218
    219
        function serialize(string memory jsonKey, string memory key, int256[] memory value)
    220
            internal
    221
            returns (string memory)
    222
        {
    223
            return vm.serializeInt(jsonKey, key, value);
    224
        }
    225
    226
        function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
    227
            return vm.serializeAddress(jsonKey, key, value);
    228
        }
    229
    230
        function serialize(string memory jsonKey, string memory key, address[] memory value)
    231
            internal
    232
            returns (string memory)
    233
        {
    234
            return vm.serializeAddress(jsonKey, key, value);
    235
        }
    236
    237
        function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
    238
            return vm.serializeBytes32(jsonKey, key, value);
    239
        }
    240
    241
        function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
    242
            internal
    243
            returns (string memory)
    244
        {
    245
            return vm.serializeBytes32(jsonKey, key, value);
    246
        }
    247
    248
        function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
    249
            return vm.serializeBytes(jsonKey, key, value);
    250
        }
    251
    252
        function serialize(string memory jsonKey, string memory key, bytes[] memory value)
    253
            internal
    254
            returns (string memory)
    255
        {
    256
            return vm.serializeBytes(jsonKey, key, value);
    257
        }
    258
    259
        function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) {
    260
            return vm.serializeString(jsonKey, key, value);
    261
        }
    262
    263
        function serialize(string memory jsonKey, string memory key, string[] memory value)
    264
            internal
    265
            returns (string memory)
    266
        {
    267
            return vm.serializeString(jsonKey, key, value);
    268
        }
    269
    270
        function write(string memory jsonKey, string memory path) internal {
    271
            vm.writeToml(jsonKey, path);
    272
        }
    273
    274
        function write(string memory jsonKey, string memory path, string memory valueKey) internal {
    275
            vm.writeToml(jsonKey, path, valueKey);
    276
        }
    277
    }
    278
    0.0% lib/forge-std/src/StdUtils.sol
    Lines covered: 0 / 21 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    import {IMulticall3} from "./interfaces/IMulticall3.sol";
    7
    import {VmSafe} from "./Vm.sol";
    8
    9
    abstract contract StdUtils {
    10
        /*//////////////////////////////////////////////////////////////////////////
    11
                                         CONSTANTS
    12
        //////////////////////////////////////////////////////////////////////////*/
    13
    14
        IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
    15
        VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
    16
        address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
    17
        uint256 private constant INT256_MIN_ABS =
    18
            57896044618658097711785492504343953926634992332820282019728792003956564819968;
    19
        uint256 private constant SECP256K1_ORDER =
    20
            115792089237316195423570985008687907852837564279074904382605163141518161494337;
    21
        uint256 private constant UINT256_MAX =
    22
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    23
    24
        // Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
    25
        address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
    26
    27
        /*//////////////////////////////////////////////////////////////////////////
    28
                                     INTERNAL FUNCTIONS
    29
        //////////////////////////////////////////////////////////////////////////*/
    30
    31
        function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    32
            require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
    33
            // If x is between min and max, return x directly. This is to ensure that dictionary values
    34
            // do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
    35
            if (x >= min && x <= max) return x;
    36
    37
            uint256 size = max - min + 1;
    38
    39
            // If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.
    40
            // This helps ensure coverage of the min/max values.
    41
            if (x <= 3 && size > x) return min + x;
    42
            if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);
    43
    44
            // Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
    45
            if (x > max) {
    46
                uint256 diff = x - max;
    47
                uint256 rem = diff % size;
    48
                if (rem == 0) return max;
    49
                result = min + rem - 1;
    50
            } else if (x < min) {
    51
                uint256 diff = min - x;
    52
                uint256 rem = diff % size;
    53
                if (rem == 0) return min;
    54
                result = max - rem + 1;
    55
            }
    56
        }
    57
    58
        function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
    59
            result = _bound(x, min, max);
    60
            console2_log_StdUtils("Bound result", result);
    61
        }
    62
    63
        function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    64
            require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
    65
    66
            // Shifting all int256 values to uint256 to use _bound function. The range of two types are:
    67
            // int256 : -(2**255) ~ (2**255 - 1)
    68
            // uint256:     0     ~ (2**256 - 1)
    69
            // So, add 2**255, INT256_MIN_ABS to the integer values.
    70
            //
    71
            // If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
    72
            // So, use `~uint256(x) + 1` instead.
    73
            uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);
    74
            uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);
    75
            uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);
    76
    77
            uint256 y = _bound(_x, _min, _max);
    78
    79
            // To move it back to int256 value, subtract INT256_MIN_ABS at here.
    80
            result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);
    81
        }
    82
    83
        function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
    84
            result = _bound(x, min, max);
    85
            console2_log_StdUtils("Bound result", vm.toString(result));
    86
        }
    87
    88
        function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
    89
            result = _bound(privateKey, 1, SECP256K1_ORDER - 1);
    90
        }
    91
    92
        function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
    93
            require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
    94
            return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
    95
        }
    96
    97
        /// @dev Compute the address a contract will be deployed at for a given deployer address and nonce
    98
        function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
    99
            console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
    100
            return vm.computeCreateAddress(deployer, nonce);
    101
        }
    102
    103
        function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
    104
            internal
    105
            pure
    106
            virtual
    107
            returns (address)
    108
        {
    109
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    110
            return vm.computeCreate2Address(salt, initcodeHash, deployer);
    111
        }
    112
    113
        /// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer
    114
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
    115
            console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
    116
            return vm.computeCreate2Address(salt, initCodeHash);
    117
        }
    118
    119
        /// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments
    120
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    121
        function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
    122
            return hashInitCode(creationCode, "");
    123
        }
    124
    125
        /// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2
    126
        /// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
    127
        /// @param args the ABI-encoded arguments to the constructor of C
    128
        function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
    129
            return keccak256(abi.encodePacked(creationCode, args));
    130
        }
    131
    132
        // Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.
    133
        function getTokenBalances(address token, address[] memory addresses)
    134
            internal
    135
            virtual
    136
            returns (uint256[] memory balances)
    137
        {
    138
            uint256 tokenCodeSize;
    139
            assembly {
    140
                tokenCodeSize := extcodesize(token)
    141
            }
    142
            require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
    143
    144
            // ABI encode the aggregate call to Multicall3.
    145
            uint256 length = addresses.length;
    146
            IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
    147
            for (uint256 i = 0; i < length; ++i) {
    148
                // 0x70a08231 = bytes4("balanceOf(address)"))
    149
                calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
    150
            }
    151
    152
            // Make the aggregate call.
    153
            (, bytes[] memory returnData) = multicall.aggregate(calls);
    154
    155
            // ABI decode the return data and return the balances.
    156
            balances = new uint256[](length);
    157
            for (uint256 i = 0; i < length; ++i) {
    158
                balances[i] = abi.decode(returnData[i], (uint256));
    159
            }
    160
        }
    161
    162
        /*//////////////////////////////////////////////////////////////////////////
    163
                                     PRIVATE FUNCTIONS
    164
        //////////////////////////////////////////////////////////////////////////*/
    165
    166
        function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
    167
            return address(uint160(uint256(bytesValue)));
    168
        }
    169
    170
        // This section is used to prevent the compilation of console, which shortens the compilation time when console is
    171
        // not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
    172
        // any breaking changes to function signatures.
    173
        function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
    174
            internal
    175
            pure
    176
            returns (function(bytes memory) internal pure fnOut)
    177
        {
    178
            assembly {
    179
                fnOut := fnIn
    180
            }
    181
        }
    182
    183
        function _sendLogPayload(bytes memory payload) internal pure {
    184
            _castLogPayloadViewToPure(_sendLogPayloadView)(payload);
    185
        }
    186
    187
        function _sendLogPayloadView(bytes memory payload) private view {
    188
            uint256 payloadLength = payload.length;
    189
            address consoleAddress = CONSOLE2_ADDRESS;
    190
            /// @solidity memory-safe-assembly
    191
            assembly {
    192
                let payloadStart := add(payload, 32)
    193
                let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
    194
            }
    195
        }
    196
    197
        function console2_log_StdUtils(string memory p0) private pure {
    198
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    199
        }
    200
    201
        function console2_log_StdUtils(string memory p0, uint256 p1) private pure {
    202
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    203
        }
    204
    205
        function console2_log_StdUtils(string memory p0, string memory p1) private pure {
    206
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    207
        }
    208
    }
    209
    100.0% lib/forge-std/src/Test.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    // 💬 ABOUT
    7
    // Forge Std's default Test.
    8
    9
    // 🧩 MODULES
    10
    import {console} from "./console.sol";
    11
    import {console2} from "./console2.sol";
    12
    import {safeconsole} from "./safeconsole.sol";
    13
    import {StdAssertions} from "./StdAssertions.sol";
    14
    import {StdChains} from "./StdChains.sol";
    15
    import {StdCheats} from "./StdCheats.sol";
    16
    import {StdConstants} from "./StdConstants.sol";
    17
    import {stdError} from "./StdError.sol";
    18
    import {StdInvariant} from "./StdInvariant.sol";
    19
    import {stdJson} from "./StdJson.sol";
    20
    import {stdMath} from "./StdMath.sol";
    21
    import {StdStorage, stdStorage} from "./StdStorage.sol";
    22
    import {StdStyle} from "./StdStyle.sol";
    23
    import {stdToml} from "./StdToml.sol";
    24
    import {StdUtils} from "./StdUtils.sol";
    25
    import {Vm} from "./Vm.sol";
    26
    27
    // 📦 BOILERPLATE
    28
    import {TestBase} from "./Base.sol";
    29
    30
    // ⭐️ TEST
    31
    abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
    32
        // Note: IS_TEST() must return true.
    33
        bool public IS_TEST = true;
    34
    }
    35
    0.0% lib/forge-std/src/Vm.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // Automatically @generated by scripts/vm.py. Do not modify manually.
    2
    3
    // SPDX-License-Identifier: MIT OR Apache-2.0
    4
    pragma solidity >=0.6.2 <0.9.0;
    5
    pragma experimental ABIEncoderV2;
    6
    7
    /// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
    8
    /// result in Script simulations differing from on-chain execution. It is recommended to only use
    9
    /// these cheats in scripts.
    10
    interface VmSafe {
    11
        /// A modification applied to either `msg.sender` or `tx.origin`. Returned by `readCallers`.
    12
        enum CallerMode {
    13
            // No caller modification is currently active.
    14
            None,
    15
            // A one time broadcast triggered by a `vm.broadcast()` call is currently active.
    16
            Broadcast,
    17
            // A recurrent broadcast triggered by a `vm.startBroadcast()` call is currently active.
    18
            RecurrentBroadcast,
    19
            // A one time prank triggered by a `vm.prank()` call is currently active.
    20
            Prank,
    21
            // A recurrent prank triggered by a `vm.startPrank()` call is currently active.
    22
            RecurrentPrank
    23
        }
    24
    25
        /// The kind of account access that occurred.
    26
        enum AccountAccessKind {
    27
            // The account was called.
    28
            Call,
    29
            // The account was called via delegatecall.
    30
            DelegateCall,
    31
            // The account was called via callcode.
    32
            CallCode,
    33
            // The account was called via staticcall.
    34
            StaticCall,
    35
            // The account was created.
    36
            Create,
    37
            // The account was selfdestructed.
    38
            SelfDestruct,
    39
            // Synthetic access indicating the current context has resumed after a previous sub-context (AccountAccess).
    40
            Resume,
    41
            // The account's balance was read.
    42
            Balance,
    43
            // The account's codesize was read.
    44
            Extcodesize,
    45
            // The account's codehash was read.
    46
            Extcodehash,
    47
            // The account's code was copied.
    48
            Extcodecopy
    49
        }
    50
    51
        /// Forge execution contexts.
    52
        enum ForgeContext {
    53
            // Test group execution context (test, coverage or snapshot).
    54
            TestGroup,
    55
            // `forge test` execution context.
    56
            Test,
    57
            // `forge coverage` execution context.
    58
            Coverage,
    59
            // `forge snapshot` execution context.
    60
            Snapshot,
    61
            // Script group execution context (dry run, broadcast or resume).
    62
            ScriptGroup,
    63
            // `forge script` execution context.
    64
            ScriptDryRun,
    65
            // `forge script --broadcast` execution context.
    66
            ScriptBroadcast,
    67
            // `forge script --resume` execution context.
    68
            ScriptResume,
    69
            // Unknown `forge` execution context.
    70
            Unknown
    71
        }
    72
    73
        /// The transaction type (`txType`) of the broadcast.
    74
        enum BroadcastTxType {
    75
            // Represents a CALL broadcast tx.
    76
            Call,
    77
            // Represents a CREATE broadcast tx.
    78
            Create,
    79
            // Represents a CREATE2 broadcast tx.
    80
            Create2
    81
        }
    82
    83
        /// An Ethereum log. Returned by `getRecordedLogs`.
    84
        struct Log {
    85
            // The topics of the log, including the signature, if any.
    86
            bytes32[] topics;
    87
            // The raw data of the log.
    88
            bytes data;
    89
            // The address of the log's emitter.
    90
            address emitter;
    91
        }
    92
    93
        /// An RPC URL and its alias. Returned by `rpcUrlStructs`.
    94
        struct Rpc {
    95
            // The alias of the RPC URL.
    96
            string key;
    97
            // The RPC URL.
    98
            string url;
    99
        }
    100
    101
        /// An RPC log object. Returned by `eth_getLogs`.
    102
        struct EthGetLogs {
    103
            // The address of the log's emitter.
    104
            address emitter;
    105
            // The topics of the log, including the signature, if any.
    106
            bytes32[] topics;
    107
            // The raw data of the log.
    108
            bytes data;
    109
            // The block hash.
    110
            bytes32 blockHash;
    111
            // The block number.
    112
            uint64 blockNumber;
    113
            // The transaction hash.
    114
            bytes32 transactionHash;
    115
            // The transaction index in the block.
    116
            uint64 transactionIndex;
    117
            // The log index.
    118
            uint256 logIndex;
    119
            // Whether the log was removed.
    120
            bool removed;
    121
        }
    122
    123
        /// A single entry in a directory listing. Returned by `readDir`.
    124
        struct DirEntry {
    125
            // The error message, if any.
    126
            string errorMessage;
    127
            // The path of the entry.
    128
            string path;
    129
            // The depth of the entry.
    130
            uint64 depth;
    131
            // Whether the entry is a directory.
    132
            bool isDir;
    133
            // Whether the entry is a symlink.
    134
            bool isSymlink;
    135
        }
    136
    137
        /// Metadata information about a file.
    138
        /// This structure is returned from the `fsMetadata` function and represents known
    139
        /// metadata about a file such as its permissions, size, modification
    140
        /// times, etc.
    141
        struct FsMetadata {
    142
            // True if this metadata is for a directory.
    143
            bool isDir;
    144
            // True if this metadata is for a symlink.
    145
            bool isSymlink;
    146
            // The size of the file, in bytes, this metadata is for.
    147
            uint256 length;
    148
            // True if this metadata is for a readonly (unwritable) file.
    149
            bool readOnly;
    150
            // The last modification time listed in this metadata.
    151
            uint256 modified;
    152
            // The last access time of this metadata.
    153
            uint256 accessed;
    154
            // The creation time listed in this metadata.
    155
            uint256 created;
    156
        }
    157
    158
        /// A wallet with a public and private key.
    159
        struct Wallet {
    160
            // The wallet's address.
    161
            address addr;
    162
            // The wallet's public key `X`.
    163
            uint256 publicKeyX;
    164
            // The wallet's public key `Y`.
    165
            uint256 publicKeyY;
    166
            // The wallet's private key.
    167
            uint256 privateKey;
    168
        }
    169
    170
        /// The result of a `tryFfi` call.
    171
        struct FfiResult {
    172
            // The exit code of the call.
    173
            int32 exitCode;
    174
            // The optionally hex-decoded `stdout` data.
    175
            bytes stdout;
    176
            // The `stderr` data.
    177
            bytes stderr;
    178
        }
    179
    180
        /// Information on the chain and fork.
    181
        struct ChainInfo {
    182
            // The fork identifier. Set to zero if no fork is active.
    183
            uint256 forkId;
    184
            // The chain ID of the current fork.
    185
            uint256 chainId;
    186
        }
    187
    188
        /// Information about a blockchain.
    189
        struct Chain {
    190
            // The chain name.
    191
            string name;
    192
            // The chain's Chain ID.
    193
            uint256 chainId;
    194
            // The chain's alias. (i.e. what gets specified in `foundry.toml`).
    195
            string chainAlias;
    196
            // A default RPC endpoint for this chain.
    197
            string rpcUrl;
    198
        }
    199
    200
        /// The result of a `stopAndReturnStateDiff` call.
    201
        struct AccountAccess {
    202
            // The chain and fork the access occurred.
    203
            ChainInfo chainInfo;
    204
            // The kind of account access that determines what the account is.
    205
            // If kind is Call, DelegateCall, StaticCall or CallCode, then the account is the callee.
    206
            // If kind is Create, then the account is the newly created account.
    207
            // If kind is SelfDestruct, then the account is the selfdestruct recipient.
    208
            // If kind is a Resume, then account represents a account context that has resumed.
    209
            AccountAccessKind kind;
    210
            // The account that was accessed.
    211
            // It's either the account created, callee or a selfdestruct recipient for CREATE, CALL or SELFDESTRUCT.
    212
            address account;
    213
            // What accessed the account.
    214
            address accessor;
    215
            // If the account was initialized or empty prior to the access.
    216
            // An account is considered initialized if it has code, a
    217
            // non-zero nonce, or a non-zero balance.
    218
            bool initialized;
    219
            // The previous balance of the accessed account.
    220
            uint256 oldBalance;
    221
            // The potential new balance of the accessed account.
    222
            // That is, all balance changes are recorded here, even if reverts occurred.
    223
            uint256 newBalance;
    224
            // Code of the account deployed by CREATE.
    225
            bytes deployedCode;
    226
            // Value passed along with the account access
    227
            uint256 value;
    228
            // Input data provided to the CREATE or CALL
    229
            bytes data;
    230
            // If this access reverted in either the current or parent context.
    231
            bool reverted;
    232
            // An ordered list of storage accesses made during an account access operation.
    233
            StorageAccess[] storageAccesses;
    234
            // Call depth traversed during the recording of state differences
    235
            uint64 depth;
    236
            // The previous nonce of the accessed account.
    237
            uint64 oldNonce;
    238
            // The new nonce of the accessed account.
    239
            uint64 newNonce;
    240
        }
    241
    242
        /// The storage accessed during an `AccountAccess`.
    243
        struct StorageAccess {
    244
            // The account whose storage was accessed.
    245
            address account;
    246
            // The slot that was accessed.
    247
            bytes32 slot;
    248
            // If the access was a write.
    249
            bool isWrite;
    250
            // The previous value of the slot.
    251
            bytes32 previousValue;
    252
            // The new value of the slot.
    253
            bytes32 newValue;
    254
            // If the access was reverted.
    255
            bool reverted;
    256
        }
    257
    258
        /// Gas used. Returned by `lastCallGas`.
    259
        struct Gas {
    260
            // The gas limit of the call.
    261
            uint64 gasLimit;
    262
            // The total gas used.
    263
            uint64 gasTotalUsed;
    264
            // DEPRECATED: The amount of gas used for memory expansion. Ref: <https://github.com/foundry-rs/foundry/pull/7934#pullrequestreview-2069236939>
    265
            uint64 gasMemoryUsed;
    266
            // The amount of gas refunded.
    267
            int64 gasRefunded;
    268
            // The amount of gas remaining.
    269
            uint64 gasRemaining;
    270
        }
    271
    272
        /// The result of the `stopDebugTraceRecording` call
    273
        struct DebugStep {
    274
            // The stack before executing the step of the run.
    275
            // stack\[0\] represents the top of the stack.
    276
            // and only stack data relevant to the opcode execution is contained.
    277
            uint256[] stack;
    278
            // The memory input data before executing the step of the run.
    279
            // only input data relevant to the opcode execution is contained.
    280
            // e.g. for MLOAD, it will have memory\[offset:offset+32\] copied here.
    281
            // the offset value can be get by the stack data.
    282
            bytes memoryInput;
    283
            // The opcode that was accessed.
    284
            uint8 opcode;
    285
            // The call depth of the step.
    286
            uint64 depth;
    287
            // Whether the call end up with out of gas error.
    288
            bool isOutOfGas;
    289
            // The contract address where the opcode is running
    290
            address contractAddr;
    291
        }
    292
    293
        /// Represents a transaction's broadcast details.
    294
        struct BroadcastTxSummary {
    295
            // The hash of the transaction that was broadcasted
    296
            bytes32 txHash;
    297
            // Represent the type of transaction among CALL, CREATE, CREATE2
    298
            BroadcastTxType txType;
    299
            // The address of the contract that was called or created.
    300
            // This is address of the contract that is created if the txType is CREATE or CREATE2.
    301
            address contractAddress;
    302
            // The block number the transaction landed in.
    303
            uint64 blockNumber;
    304
            // Status of the transaction, retrieved from the transaction receipt.
    305
            bool success;
    306
        }
    307
    308
        /// Holds a signed EIP-7702 authorization for an authority account to delegate to an implementation.
    309
        struct SignedDelegation {
    310
            // The y-parity of the recovered secp256k1 signature (0 or 1).
    311
            uint8 v;
    312
            // First 32 bytes of the signature.
    313
            bytes32 r;
    314
            // Second 32 bytes of the signature.
    315
            bytes32 s;
    316
            // The current nonce of the authority account at signing time.
    317
            // Used to ensure signature can't be replayed after account nonce changes.
    318
            uint64 nonce;
    319
            // Address of the contract implementation that will be delegated to.
    320
            // Gets encoded into delegation code: 0xef0100 || implementation.
    321
            address implementation;
    322
        }
    323
    324
        /// Represents a "potential" revert reason from a single subsequent call when using `vm.assumeNoReverts`.
    325
        /// Reverts that match will result in a FOUNDRY::ASSUME rejection, whereas unmatched reverts will be surfaced
    326
        /// as normal.
    327
        struct PotentialRevert {
    328
            // The allowed origin of the revert opcode; address(0) allows reverts from any address
    329
            address reverter;
    330
            // When true, only matches on the beginning of the revert data, otherwise, matches on entire revert data
    331
            bool partialMatch;
    332
            // The data to use to match encountered reverts
    333
            bytes revertData;
    334
        }
    335
    336
        /// An EIP-2930 access list item.
    337
        struct AccessListItem {
    338
            // The address to be added in access list.
    339
            address target;
    340
            // The storage keys to be added in access list.
    341
            bytes32[] storageKeys;
    342
        }
    343
    344
        // ======== Crypto ========
    345
    346
        /// Derives a private key from the name, labels the account with that name, and returns the wallet.
    347
        function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);
    348
    349
        /// Generates a wallet from the private key and returns the wallet.
    350
        function createWallet(uint256 privateKey) external returns (Wallet memory wallet);
    351
    352
        /// Generates a wallet from the private key, labels the account with that name, and returns the wallet.
    353
        function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);
    354
    355
        /// Derive a private key from a provided mnemonic string (or mnemonic file path)
    356
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    357
        function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);
    358
    359
        /// Derive a private key from a provided mnemonic string (or mnemonic file path)
    360
        /// at `{derivationPath}{index}`.
    361
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
    362
            external
    363
            pure
    364
            returns (uint256 privateKey);
    365
    366
        /// Derive a private key from a provided mnemonic string (or mnemonic file path) in the specified language
    367
        /// at the derivation path `m/44'/60'/0'/0/{index}`.
    368
        function deriveKey(string calldata mnemonic, uint32 index, string calldata language)
    369
            external
    370
            pure
    371
            returns (uint256 privateKey);
    372
    373
        /// Derive a private key from a provided mnemonic string (or mnemonic file path) in the specified language
    374
        /// at `{derivationPath}{index}`.
    375
        function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index, string calldata language)
    376
            external
    377
            pure
    378
            returns (uint256 privateKey);
    379
    380
        /// Derives secp256r1 public key from the provided `privateKey`.
    381
        function publicKeyP256(uint256 privateKey) external pure returns (uint256 publicKeyX, uint256 publicKeyY);
    382
    383
        /// Adds a private key to the local forge wallet and returns the address.
    384
        function rememberKey(uint256 privateKey) external returns (address keyAddr);
    385
    386
        /// Derive a set number of wallets from a mnemonic at the derivation path `m/44'/60'/0'/0/{0..count}`.
    387
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    388
        function rememberKeys(string calldata mnemonic, string calldata derivationPath, uint32 count)
    389
            external
    390
            returns (address[] memory keyAddrs);
    391
    392
        /// Derive a set number of wallets from a mnemonic in the specified language at the derivation path `m/44'/60'/0'/0/{0..count}`.
    393
        /// The respective private keys are saved to the local forge wallet for later use and their addresses are returned.
    394
        function rememberKeys(
    395
            string calldata mnemonic,
    396
            string calldata derivationPath,
    397
            string calldata language,
    398
            uint32 count
    399
        ) external returns (address[] memory keyAddrs);
    400
    401
        /// Signs data with a `Wallet`.
    402
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    403
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    404
        /// This format reduces the signature size from 65 to 64 bytes.
    405
        function signCompact(Wallet calldata wallet, bytes32 digest) external returns (bytes32 r, bytes32 vs);
    406
    407
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    408
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    409
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    410
        /// This format reduces the signature size from 65 to 64 bytes.
    411
        function signCompact(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    412
    413
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    414
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    415
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    416
        /// This format reduces the signature size from 65 to 64 bytes.
    417
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    418
        /// if exactly one signer is provided to the script, that signer is used.
    419
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    420
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    421
        function signCompact(bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    422
    423
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    424
        /// Returns a compact signature (`r`, `vs`) as per EIP-2098, where `vs` encodes both the
    425
        /// signature's `s` value, and the recovery id `v` in a single bytes32.
    426
        /// This format reduces the signature size from 65 to 64 bytes.
    427
        /// Raises error if none of the signers passed into the script have provided address.
    428
        function signCompact(address signer, bytes32 digest) external pure returns (bytes32 r, bytes32 vs);
    429
    430
        /// Signs `digest` with `privateKey` using the secp256r1 curve.
    431
        function signP256(uint256 privateKey, bytes32 digest) external pure returns (bytes32 r, bytes32 s);
    432
    433
        /// Signs `digest` with `privateKey` on the secp256k1 curve, using the given `nonce`
    434
        /// as the raw ephemeral k value in ECDSA (instead of deriving it deterministically).
    435
        function signWithNonceUnsafe(uint256 privateKey, bytes32 digest, uint256 nonce)
    436
            external
    437
            pure
    438
            returns (uint8 v, bytes32 r, bytes32 s);
    439
    440
        /// Signs data with a `Wallet`.
    441
        function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
    442
    443
        /// Signs `digest` with `privateKey` using the secp256k1 curve.
    444
        function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    445
    446
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    447
        /// If `--sender` is provided, the signer with provided address is used, otherwise,
    448
        /// if exactly one signer is provided to the script, that signer is used.
    449
        /// Raises error if signer passed through `--sender` does not match any unlocked signers or
    450
        /// if `--sender` is not provided and not exactly one signer is passed to the script.
    451
        function sign(bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    452
    453
        /// Signs `digest` with signer provided to script using the secp256k1 curve.
    454
        /// Raises error if none of the signers passed into the script have provided address.
    455
        function sign(address signer, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
    456
    457
        // ======== Environment ========
    458
    459
        /// Gets the environment variable `name` and parses it as `address`.
    460
        /// Reverts if the variable was not found or could not be parsed.
    461
        function envAddress(string calldata name) external view returns (address value);
    462
    463
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    464
        /// Reverts if the variable was not found or could not be parsed.
    465
        function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);
    466
    467
        /// Gets the environment variable `name` and parses it as `bool`.
    468
        /// Reverts if the variable was not found or could not be parsed.
    469
        function envBool(string calldata name) external view returns (bool value);
    470
    471
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    472
        /// Reverts if the variable was not found or could not be parsed.
    473
        function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);
    474
    475
        /// Gets the environment variable `name` and parses it as `bytes32`.
    476
        /// Reverts if the variable was not found or could not be parsed.
    477
        function envBytes32(string calldata name) external view returns (bytes32 value);
    478
    479
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    480
        /// Reverts if the variable was not found or could not be parsed.
    481
        function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);
    482
    483
        /// Gets the environment variable `name` and parses it as `bytes`.
    484
        /// Reverts if the variable was not found or could not be parsed.
    485
        function envBytes(string calldata name) external view returns (bytes memory value);
    486
    487
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    488
        /// Reverts if the variable was not found or could not be parsed.
    489
        function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);
    490
    491
        /// Gets the environment variable `name` and returns true if it exists, else returns false.
    492
        function envExists(string calldata name) external view returns (bool result);
    493
    494
        /// Gets the environment variable `name` and parses it as `int256`.
    495
        /// Reverts if the variable was not found or could not be parsed.
    496
        function envInt(string calldata name) external view returns (int256 value);
    497
    498
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    499
        /// Reverts if the variable was not found or could not be parsed.
    500
        function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);
    501
    502
        /// Gets the environment variable `name` and parses it as `bool`.
    503
        /// Reverts if the variable could not be parsed.
    504
        /// Returns `defaultValue` if the variable was not found.
    505
        function envOr(string calldata name, bool defaultValue) external view returns (bool value);
    506
    507
        /// Gets the environment variable `name` and parses it as `uint256`.
    508
        /// Reverts if the variable could not be parsed.
    509
        /// Returns `defaultValue` if the variable was not found.
    510
        function envOr(string calldata name, uint256 defaultValue) external view returns (uint256 value);
    511
    512
        /// Gets the environment variable `name` and parses it as an array of `address`, delimited by `delim`.
    513
        /// Reverts if the variable could not be parsed.
    514
        /// Returns `defaultValue` if the variable was not found.
    515
        function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
    516
            external
    517
            view
    518
            returns (address[] memory value);
    519
    520
        /// Gets the environment variable `name` and parses it as an array of `bytes32`, delimited by `delim`.
    521
        /// Reverts if the variable could not be parsed.
    522
        /// Returns `defaultValue` if the variable was not found.
    523
        function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
    524
            external
    525
            view
    526
            returns (bytes32[] memory value);
    527
    528
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    529
        /// Reverts if the variable could not be parsed.
    530
        /// Returns `defaultValue` if the variable was not found.
    531
        function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
    532
            external
    533
            view
    534
            returns (string[] memory value);
    535
    536
        /// Gets the environment variable `name` and parses it as an array of `bytes`, delimited by `delim`.
    537
        /// Reverts if the variable could not be parsed.
    538
        /// Returns `defaultValue` if the variable was not found.
    539
        function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
    540
            external
    541
            view
    542
            returns (bytes[] memory value);
    543
    544
        /// Gets the environment variable `name` and parses it as `int256`.
    545
        /// Reverts if the variable could not be parsed.
    546
        /// Returns `defaultValue` if the variable was not found.
    547
        function envOr(string calldata name, int256 defaultValue) external view returns (int256 value);
    548
    549
        /// Gets the environment variable `name` and parses it as `address`.
    550
        /// Reverts if the variable could not be parsed.
    551
        /// Returns `defaultValue` if the variable was not found.
    552
        function envOr(string calldata name, address defaultValue) external view returns (address value);
    553
    554
        /// Gets the environment variable `name` and parses it as `bytes32`.
    555
        /// Reverts if the variable could not be parsed.
    556
        /// Returns `defaultValue` if the variable was not found.
    557
        function envOr(string calldata name, bytes32 defaultValue) external view returns (bytes32 value);
    558
    559
        /// Gets the environment variable `name` and parses it as `string`.
    560
        /// Reverts if the variable could not be parsed.
    561
        /// Returns `defaultValue` if the variable was not found.
    562
        function envOr(string calldata name, string calldata defaultValue) external view returns (string memory value);
    563
    564
        /// Gets the environment variable `name` and parses it as `bytes`.
    565
        /// Reverts if the variable could not be parsed.
    566
        /// Returns `defaultValue` if the variable was not found.
    567
        function envOr(string calldata name, bytes calldata defaultValue) external view returns (bytes memory value);
    568
    569
        /// Gets the environment variable `name` and parses it as an array of `bool`, delimited by `delim`.
    570
        /// Reverts if the variable could not be parsed.
    571
        /// Returns `defaultValue` if the variable was not found.
    572
        function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
    573
            external
    574
            view
    575
            returns (bool[] memory value);
    576
    577
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    578
        /// Reverts if the variable could not be parsed.
    579
        /// Returns `defaultValue` if the variable was not found.
    580
        function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
    581
            external
    582
            view
    583
            returns (uint256[] memory value);
    584
    585
        /// Gets the environment variable `name` and parses it as an array of `int256`, delimited by `delim`.
    586
        /// Reverts if the variable could not be parsed.
    587
        /// Returns `defaultValue` if the variable was not found.
    588
        function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
    589
            external
    590
            view
    591
            returns (int256[] memory value);
    592
    593
        /// Gets the environment variable `name` and parses it as `string`.
    594
        /// Reverts if the variable was not found or could not be parsed.
    595
        function envString(string calldata name) external view returns (string memory value);
    596
    597
        /// Gets the environment variable `name` and parses it as an array of `string`, delimited by `delim`.
    598
        /// Reverts if the variable was not found or could not be parsed.
    599
        function envString(string calldata name, string calldata delim) external view returns (string[] memory value);
    600
    601
        /// Gets the environment variable `name` and parses it as `uint256`.
    602
        /// Reverts if the variable was not found or could not be parsed.
    603
        function envUint(string calldata name) external view returns (uint256 value);
    604
    605
        /// Gets the environment variable `name` and parses it as an array of `uint256`, delimited by `delim`.
    606
        /// Reverts if the variable was not found or could not be parsed.
    607
        function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);
    608
    609
        /// Returns true if `forge` command was executed in given context.
    610
        function isContext(ForgeContext context) external view returns (bool result);
    611
    612
        /// Resolves the env variable placeholders of a given input string.
    613
        function resolveEnv(string calldata input) external returns (string memory);
    614
    615
        /// Sets environment variables.
    616
        function setEnv(string calldata name, string calldata value) external;
    617
    618
        // ======== EVM ========
    619
    620
        /// Gets all accessed reads and write slot from a `vm.record` session, for a given address.
    621
        function accesses(address target) external view returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);
    622
    623
        /// Gets the address for a given private key.
    624
        function addr(uint256 privateKey) external pure returns (address keyAddr);
    625
    626
        /// Gets all the logs according to specified filter.
    627
        function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
    628
            external
    629
            view
    630
            returns (EthGetLogs[] memory logs);
    631
    632
        /// Gets the current `block.blobbasefee`.
    633
        /// You should use this instead of `block.blobbasefee` if you use `vm.blobBaseFee`, as `block.blobbasefee` is assumed to be constant across a transaction,
    634
        /// and as a result will get optimized out by the compiler.
    635
        /// See https://github.com/foundry-rs/foundry/issues/6180
    636
        function getBlobBaseFee() external view returns (uint256 blobBaseFee);
    637
    638
        /// Gets the current `block.number`.
    639
        /// You should use this instead of `block.number` if you use `vm.roll`, as `block.number` is assumed to be constant across a transaction,
    640
        /// and as a result will get optimized out by the compiler.
    641
        /// See https://github.com/foundry-rs/foundry/issues/6180
    642
        function getBlockNumber() external view returns (uint256 height);
    643
    644
        /// Gets the current `block.timestamp`.
    645
        /// You should use this instead of `block.timestamp` if you use `vm.warp`, as `block.timestamp` is assumed to be constant across a transaction,
    646
        /// and as a result will get optimized out by the compiler.
    647
        /// See https://github.com/foundry-rs/foundry/issues/6180
    648
        function getBlockTimestamp() external view returns (uint256 timestamp);
    649
    650
        /// Gets the current `block.chainid` of the currently selected environment.
    651
        /// You should use this instead of `block.chainid` if you use `vm.selectFork` or `vm.createSelectFork`, as `block.chainid` could be assumed
    652
        /// to be constant across a transaction, and as a result will get optimized out by the compiler.
    653
        /// See https://github.com/foundry-rs/foundry/issues/6180
    654
        function getChainId() external view returns (uint256 blockChainId);
    655
    656
        /// Returns the test or script execution evm version.
    657
        /// **Note:** The execution evm version is not the same as the compilation one.
    658
        function getEvmVersion() external pure returns (string memory evm);
    659
    660
        /// Gets the map key and parent of a mapping at a given slot, for a given address.
    661
        function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
    662
            external
    663
            view
    664
            returns (bool found, bytes32 key, bytes32 parent);
    665
    666
        /// Gets the number of elements in the mapping at the given slot, for a given address.
    667
        function getMappingLength(address target, bytes32 mappingSlot) external view returns (uint256 length);
    668
    669
        /// Gets the elements at index idx of the mapping at the given slot, for a given address. The
    670
        /// index must be less than the length of the mapping (i.e. the number of keys in the mapping).
    671
        function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external view returns (bytes32 value);
    672
    673
        /// Gets the nonce of an account.
    674
        function getNonce(address account) external view returns (uint64 nonce);
    675
    676
        /// Get the nonce of a `Wallet`.
    677
        function getNonce(Wallet calldata wallet) external view returns (uint64 nonce);
    678
    679
        /// Gets the RLP encoded block header for a given block number.
    680
        /// Returns the block header in the same format as `cast block <block_number> --raw`.
    681
        function getRawBlockHeader(uint256 blockNumber) external view returns (bytes memory rlpHeader);
    682
    683
        /// Gets all the recorded logs.
    684
        function getRecordedLogs() external view returns (Log[] memory logs);
    685
    686
        /// Returns state diffs from current `vm.startStateDiffRecording` session.
    687
        function getStateDiff() external view returns (string memory diff);
    688
    689
        /// Returns state diffs from current `vm.startStateDiffRecording` session, in json format.
    690
        function getStateDiffJson() external view returns (string memory diff);
    691
    692
        /// Returns an array of `StorageAccess` from current `vm.stateStateDiffRecording` session
    693
        function getStorageAccesses() external view returns (StorageAccess[] memory storageAccesses);
    694
    695
        /// Returns an array of storage slots occupied by the specified variable.
    696
        function getStorageSlots(address target, string calldata variableName)
    697
            external
    698
            view
    699
            returns (uint256[] memory slots);
    700
    701
        /// Gets the gas used in the last call from the callee perspective.
    702
        function lastCallGas() external view returns (Gas memory gas);
    703
    704
        /// Loads a storage slot from an address.
    705
        function load(address target, bytes32 slot) external view returns (bytes32 data);
    706
    707
        /// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.
    708
        function pauseGasMetering() external;
    709
    710
        /// Records all storage reads and writes. Use `accesses` to get the recorded data.
    711
        /// Subsequent calls to `record` will clear the previous data.
    712
        function record() external;
    713
    714
        /// Record all the transaction logs.
    715
        function recordLogs() external;
    716
    717
        /// Reset gas metering (i.e. gas usage is set to gas limit).
    718
        function resetGasMetering() external;
    719
    720
        /// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.
    721
        function resumeGasMetering() external;
    722
    723
        /// Performs an Ethereum JSON-RPC request to the current fork URL.
    724
        function rpc(string calldata method, string calldata params) external returns (bytes memory data);
    725
    726
        /// Performs an Ethereum JSON-RPC request to the given endpoint.
    727
        function rpc(string calldata urlOrAlias, string calldata method, string calldata params)
    728
            external
    729
            returns (bytes memory data);
    730
    731
        /// Set the exact test or script execution evm version, e.g. `berlin`, `cancun`.
    732
        /// **Note:** The execution evm version is not the same as the compilation one.
    733
        function setEvmVersion(string calldata evm) external;
    734
    735
        /// Records the debug trace during the run.
    736
        function startDebugTraceRecording() external;
    737
    738
        /// Starts recording all map SSTOREs for later retrieval.
    739
        function startMappingRecording() external;
    740
    741
        /// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,
    742
        /// along with the context of the calls
    743
        function startStateDiffRecording() external;
    744
    745
        /// Stop debug trace recording and returns the recorded debug trace.
    746
        function stopAndReturnDebugTraceRecording() external returns (DebugStep[] memory step);
    747
    748
        /// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.
    749
        function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);
    750
    751
        /// Stops recording all map SSTOREs for later retrieval and clears the recorded data.
    752
        function stopMappingRecording() external;
    753
    754
        /// Stops recording storage reads and writes.
    755
        function stopRecord() external;
    756
    757
        // ======== Filesystem ========
    758
    759
        /// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
    760
        /// `path` is relative to the project root.
    761
        function closeFile(string calldata path) external;
    762
    763
        /// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.
    764
        /// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.
    765
        /// Both `from` and `to` are relative to the project root.
    766
        function copyFile(string calldata from, string calldata to) external returns (uint64 copied);
    767
    768
        /// Creates a new, empty directory at the provided path.
    769
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    770
        /// - User lacks permissions to modify `path`.
    771
        /// - A parent of the given path doesn't exist and `recursive` is false.
    772
        /// - `path` already exists and `recursive` is false.
    773
        /// `path` is relative to the project root.
    774
        function createDir(string calldata path, bool recursive) external;
    775
    776
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    777
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    778
        /// Reverts if the target artifact contains unlinked library placeholders.
    779
        function deployCode(string calldata artifactPath) external returns (address deployedAddress);
    780
    781
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    782
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    783
        /// Reverts if the target artifact contains unlinked library placeholders.
    784
        /// Additionally accepts abi-encoded constructor arguments.
    785
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs)
    786
            external
    787
            returns (address deployedAddress);
    788
    789
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    790
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    791
        /// Reverts if the target artifact contains unlinked library placeholders.
    792
        /// Additionally accepts `msg.value`.
    793
        function deployCode(string calldata artifactPath, uint256 value) external returns (address deployedAddress);
    794
    795
        /// Deploys a contract from an artifact file. Takes in the relative path to the json file or the path to the
    796
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    797
        /// Reverts if the target artifact contains unlinked library placeholders.
    798
        /// Additionally accepts abi-encoded constructor arguments and `msg.value`.
    799
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value)
    800
            external
    801
            returns (address deployedAddress);
    802
    803
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    804
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    805
        /// Reverts if the target artifact contains unlinked library placeholders.
    806
        function deployCode(string calldata artifactPath, bytes32 salt) external returns (address deployedAddress);
    807
    808
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    809
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    810
        /// Reverts if the target artifact contains unlinked library placeholders.
    811
        /// Additionally accepts abi-encoded constructor arguments.
    812
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, bytes32 salt)
    813
            external
    814
            returns (address deployedAddress);
    815
    816
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    817
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    818
        /// Reverts if the target artifact contains unlinked library placeholders.
    819
        /// Additionally accepts `msg.value`.
    820
        function deployCode(string calldata artifactPath, uint256 value, bytes32 salt)
    821
            external
    822
            returns (address deployedAddress);
    823
    824
        /// Deploys a contract from an artifact file, using the CREATE2 salt. Takes in the relative path to the json file or the path to the
    825
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    826
        /// Reverts if the target artifact contains unlinked library placeholders.
    827
        /// Additionally accepts abi-encoded constructor arguments and `msg.value`.
    828
        function deployCode(string calldata artifactPath, bytes calldata constructorArgs, uint256 value, bytes32 salt)
    829
            external
    830
            returns (address deployedAddress);
    831
    832
        /// Returns true if the given path points to an existing entity, else returns false.
    833
        function exists(string calldata path) external view returns (bool result);
    834
    835
        /// Performs a foreign function call via the terminal.
    836
        function ffi(string[] calldata commandInput) external returns (bytes memory result);
    837
    838
        /// Given a path, query the file system to get information about a file, directory, etc.
    839
        function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);
    840
    841
        /// Gets the artifact path from code (aka. creation code).
    842
        function getArtifactPathByCode(bytes calldata code) external view returns (string memory path);
    843
    844
        /// Gets the artifact path from deployed code (aka. runtime code).
    845
        function getArtifactPathByDeployedCode(bytes calldata deployedCode) external view returns (string memory path);
    846
    847
        /// Returns the most recent broadcast for the given contract on `chainId` matching `txType`.
    848
        /// For example:
    849
        /// The most recent deployment can be fetched by passing `txType` as `CREATE` or `CREATE2`.
    850
        /// The most recent call can be fetched by passing `txType` as `CALL`.
    851
        function getBroadcast(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    852
            external
    853
            view
    854
            returns (BroadcastTxSummary memory);
    855
    856
        /// Returns all broadcasts for the given contract on `chainId` with the specified `txType`.
    857
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    858
        function getBroadcasts(string calldata contractName, uint64 chainId, BroadcastTxType txType)
    859
            external
    860
            view
    861
            returns (BroadcastTxSummary[] memory);
    862
    863
        /// Returns all broadcasts for the given contract on `chainId`.
    864
        /// Sorted such that the most recent broadcast is the first element, and the oldest is the last. i.e descending order of BroadcastTxSummary.blockNumber.
    865
        function getBroadcasts(string calldata contractName, uint64 chainId)
    866
            external
    867
            view
    868
            returns (BroadcastTxSummary[] memory);
    869
    870
        /// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    871
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    872
        function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);
    873
    874
        /// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file or the path to the
    875
        /// artifact in the form of <path>:<contract>:<version> where <contract> and <version> parts are optional.
    876
        function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);
    877
    878
        /// Returns the most recent deployment for the current `chainId`.
    879
        function getDeployment(string calldata contractName) external view returns (address deployedAddress);
    880
    881
        /// Returns the most recent deployment for the given contract on `chainId`
    882
        function getDeployment(string calldata contractName, uint64 chainId) external view returns (address deployedAddress);
    883
    884
        /// Returns all deployments for the given contract on `chainId`
    885
        /// Sorted in descending order of deployment time i.e descending order of BroadcastTxSummary.blockNumber.
    886
        /// The most recent deployment is the first element, and the oldest is the last.
    887
        function getDeployments(string calldata contractName, uint64 chainId)
    888
            external
    889
            view
    890
            returns (address[] memory deployedAddresses);
    891
    892
        /// Returns true if the path exists on disk and is pointing at a directory, else returns false.
    893
        function isDir(string calldata path) external view returns (bool result);
    894
    895
        /// Returns true if the path exists on disk and is pointing at a regular file, else returns false.
    896
        function isFile(string calldata path) external view returns (bool result);
    897
    898
        /// Get the path of the current project root.
    899
        function projectRoot() external view returns (string memory path);
    900
    901
        /// Prompts the user for a string value in the terminal.
    902
        function prompt(string calldata promptText) external returns (string memory input);
    903
    904
        /// Prompts the user for an address in the terminal.
    905
        function promptAddress(string calldata promptText) external returns (address);
    906
    907
        /// Prompts the user for a hidden string value in the terminal.
    908
        function promptSecret(string calldata promptText) external returns (string memory input);
    909
    910
        /// Prompts the user for hidden uint256 in the terminal (usually pk).
    911
        function promptSecretUint(string calldata promptText) external returns (uint256);
    912
    913
        /// Prompts the user for uint256 in the terminal.
    914
        function promptUint(string calldata promptText) external returns (uint256);
    915
    916
        /// Reads the directory at the given path recursively, up to `maxDepth`.
    917
        /// `maxDepth` defaults to 1, meaning only the direct children of the given directory will be returned.
    918
        /// Follows symbolic links if `followLinks` is true.
    919
        function readDir(string calldata path) external view returns (DirEntry[] memory entries);
    920
    921
        /// See `readDir(string)`.
    922
        function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);
    923
    924
        /// See `readDir(string)`.
    925
        function readDir(string calldata path, uint64 maxDepth, bool followLinks)
    926
            external
    927
            view
    928
            returns (DirEntry[] memory entries);
    929
    930
        /// Reads the entire content of file to string. `path` is relative to the project root.
    931
        function readFile(string calldata path) external view returns (string memory data);
    932
    933
        /// Reads the entire content of file as binary. `path` is relative to the project root.
    934
        function readFileBinary(string calldata path) external view returns (bytes memory data);
    935
    936
        /// Reads next line of file to string.
    937
        function readLine(string calldata path) external view returns (string memory line);
    938
    939
        /// Reads a symbolic link, returning the path that the link points to.
    940
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    941
        /// - `path` is not a symbolic link.
    942
        /// - `path` does not exist.
    943
        function readLink(string calldata linkPath) external view returns (string memory targetPath);
    944
    945
        /// Removes a directory at the provided path.
    946
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    947
        /// - `path` doesn't exist.
    948
        /// - `path` isn't a directory.
    949
        /// - User lacks permissions to modify `path`.
    950
        /// - The directory is not empty and `recursive` is false.
    951
        /// `path` is relative to the project root.
    952
        function removeDir(string calldata path, bool recursive) external;
    953
    954
        /// Removes a file from the filesystem.
    955
        /// This cheatcode will revert in the following situations, but is not limited to just these cases:
    956
        /// - `path` points to a directory.
    957
        /// - The file doesn't exist.
    958
        /// - The user lacks permissions to remove the file.
    959
        /// `path` is relative to the project root.
    960
        function removeFile(string calldata path) external;
    961
    962
        /// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr.
    963
        function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);
    964
    965
        /// Returns the time since unix epoch in milliseconds.
    966
        function unixTime() external view returns (uint256 milliseconds);
    967
    968
        /// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
    969
        /// `path` is relative to the project root.
    970
        function writeFile(string calldata path, string calldata data) external;
    971
    972
        /// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.
    973
        /// `path` is relative to the project root.
    974
        function writeFileBinary(string calldata path, bytes calldata data) external;
    975
    976
        /// Writes line to file, creating a file if it does not exist.
    977
        /// `path` is relative to the project root.
    978
        function writeLine(string calldata path, string calldata data) external;
    979
    980
        // ======== JSON ========
    981
    982
        /// Checks if `key` exists in a JSON object.
    983
        function keyExistsJson(string calldata json, string calldata key) external view returns (bool);
    984
    985
        /// Parses a string of JSON data at `key` and coerces it to `address`.
    986
        function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);
    987
    988
        /// Parses a string of JSON data at `key` and coerces it to `address[]`.
    989
        function parseJsonAddressArray(string calldata json, string calldata key) external pure returns (address[] memory);
    990
    991
        /// Parses a string of JSON data at `key` and coerces it to `bool`.
    992
        function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);
    993
    994
        /// Parses a string of JSON data at `key` and coerces it to `bool[]`.
    995
        function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);
    996
    997
        /// Parses a string of JSON data at `key` and coerces it to `bytes`.
    998
        function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);
    999
    1000
        /// Parses a string of JSON data at `key` and coerces it to `bytes32`.
    1001
        function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);
    1002
    1003
        /// Parses a string of JSON data at `key` and coerces it to `bytes32[]`.
    1004
        function parseJsonBytes32Array(string calldata json, string calldata key) external pure returns (bytes32[] memory);
    1005
    1006
        /// Parses a string of JSON data at `key` and coerces it to `bytes[]`.
    1007
        function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);
    1008
    1009
        /// Parses a string of JSON data at `key` and coerces it to `int256`.
    1010
        function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);
    1011
    1012
        /// Parses a string of JSON data at `key` and coerces it to `int256[]`.
    1013
        function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);
    1014
    1015
        /// Returns an array of all the keys in a JSON object.
    1016
        function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);
    1017
    1018
        /// Parses a string of JSON data at `key` and coerces it to `string`.
    1019
        function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);
    1020
    1021
        /// Parses a string of JSON data at `key` and coerces it to `string[]`.
    1022
        function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);
    1023
    1024
        /// Parses a string of JSON data at `key` and coerces it to type array corresponding to `typeDescription`.
    1025
        function parseJsonTypeArray(string calldata json, string calldata key, string calldata typeDescription)
    1026
            external
    1027
            pure
    1028
            returns (bytes memory);
    1029
    1030
        /// Parses a string of JSON data and coerces it to type corresponding to `typeDescription`.
    1031
        function parseJsonType(string calldata json, string calldata typeDescription) external pure returns (bytes memory);
    1032
    1033
        /// Parses a string of JSON data at `key` and coerces it to type corresponding to `typeDescription`.
    1034
        function parseJsonType(string calldata json, string calldata key, string calldata typeDescription)
    1035
            external
    1036
            pure
    1037
            returns (bytes memory);
    1038
    1039
        /// Parses a string of JSON data at `key` and coerces it to `uint256`.
    1040
        function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);
    1041
    1042
        /// Parses a string of JSON data at `key` and coerces it to `uint256[]`.
    1043
        function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);
    1044
    1045
        /// ABI-encodes a JSON object.
    1046
        function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);
    1047
    1048
        /// ABI-encodes a JSON object at `key`.
    1049
        function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);
    1050
    1051
        /// See `serializeJson`.
    1052
        function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
    1053
            external
    1054
            returns (string memory json);
    1055
    1056
        /// See `serializeJson`.
    1057
        function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
    1058
            external
    1059
            returns (string memory json);
    1060
    1061
        /// See `serializeJson`.
    1062
        function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
    1063
            external
    1064
            returns (string memory json);
    1065
    1066
        /// See `serializeJson`.
    1067
        function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
    1068
            external
    1069
            returns (string memory json);
    1070
    1071
        /// See `serializeJson`.
    1072
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
    1073
            external
    1074
            returns (string memory json);
    1075
    1076
        /// See `serializeJson`.
    1077
        function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
    1078
            external
    1079
            returns (string memory json);
    1080
    1081
        /// See `serializeJson`.
    1082
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
    1083
            external
    1084
            returns (string memory json);
    1085
    1086
        /// See `serializeJson`.
    1087
        function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
    1088
            external
    1089
            returns (string memory json);
    1090
    1091
        /// See `serializeJson`.
    1092
        function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
    1093
            external
    1094
            returns (string memory json);
    1095
    1096
        /// See `serializeJson`.
    1097
        function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
    1098
            external
    1099
            returns (string memory json);
    1100
    1101
        /// Serializes a key and value to a JSON object stored in-memory that can be later written to a file.
    1102
        /// Returns the stringified version of the specific JSON file up to that moment.
    1103
        function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);
    1104
    1105
        /// See `serializeJson`.
    1106
        function serializeJsonType(string calldata typeDescription, bytes calldata value)
    1107
            external
    1108
            pure
    1109
            returns (string memory json);
    1110
    1111
        /// See `serializeJson`.
    1112
        function serializeJsonType(
    1113
            string calldata objectKey,
    1114
            string calldata valueKey,
    1115
            string calldata typeDescription,
    1116
            bytes calldata value
    1117
        ) external returns (string memory json);
    1118
    1119
        /// See `serializeJson`.
    1120
        function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
    1121
            external
    1122
            returns (string memory json);
    1123
    1124
        /// See `serializeJson`.
    1125
        function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
    1126
            external
    1127
            returns (string memory json);
    1128
    1129
        /// See `serializeJson`.
    1130
        function serializeUintToHex(string calldata objectKey, string calldata valueKey, uint256 value)
    1131
            external
    1132
            returns (string memory json);
    1133
    1134
        /// See `serializeJson`.
    1135
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
    1136
            external
    1137
            returns (string memory json);
    1138
    1139
        /// See `serializeJson`.
    1140
        function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
    1141
            external
    1142
            returns (string memory json);
    1143
    1144
        /// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
    1145
        function writeJson(string calldata json, string calldata path) external;
    1146
    1147
        /// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key.>
    1148
        /// This is useful to replace a specific value of a JSON file, without having to parse the entire thing.
    1149
        /// This cheatcode will create new keys if they didn't previously exist.
    1150
        function writeJson(string calldata json, string calldata path, string calldata valueKey) external;
    1151
    1152
        /// Checks if `key` exists in a JSON object
    1153
        /// `keyExists` is being deprecated in favor of `keyExistsJson`. It will be removed in future versions.
    1154
        function keyExists(string calldata json, string calldata key) external view returns (bool);
    1155
    1156
        // ======== Scripting ========
    1157
    1158
        /// Attach an EIP-4844 blob to the next call
    1159
        function attachBlob(bytes calldata blob) external;
    1160
    1161
        /// Designate the next call as an EIP-7702 transaction
    1162
        function attachDelegation(SignedDelegation calldata signedDelegation) external;
    1163
    1164
        /// Designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
    1165
        function attachDelegation(SignedDelegation calldata signedDelegation, bool crossChain) external;
    1166
    1167
        /// Takes a signed transaction and broadcasts it to the network.
    1168
        function broadcastRawTransaction(bytes calldata data) external;
    1169
    1170
        /// Has the next call (at this call depth only) create transactions that can later be signed and sent onchain.
    1171
        /// Broadcasting address is determined by checking the following in order:
    1172
        /// 1. If `--sender` argument was provided, that address is used.
    1173
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1174
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1175
        function broadcast() external;
    1176
    1177
        /// Has the next call (at this call depth only) create a transaction with the address provided
    1178
        /// as the sender that can later be signed and sent onchain.
    1179
        function broadcast(address signer) external;
    1180
    1181
        /// Has the next call (at this call depth only) create a transaction with the private key
    1182
        /// provided as the sender that can later be signed and sent onchain.
    1183
        function broadcast(uint256 privateKey) external;
    1184
    1185
        /// Returns addresses of available unlocked wallets in the script environment.
    1186
        function getWallets() external view returns (address[] memory wallets);
    1187
    1188
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction
    1189
        function signAndAttachDelegation(address implementation, uint256 privateKey)
    1190
            external
    1191
            returns (SignedDelegation memory signedDelegation);
    1192
    1193
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction for specific nonce
    1194
        function signAndAttachDelegation(address implementation, uint256 privateKey, uint64 nonce)
    1195
            external
    1196
            returns (SignedDelegation memory signedDelegation);
    1197
    1198
        /// Sign an EIP-7702 authorization and designate the next call as an EIP-7702 transaction, with optional cross-chain validity.
    1199
        function signAndAttachDelegation(address implementation, uint256 privateKey, bool crossChain)
    1200
            external
    1201
            returns (SignedDelegation memory signedDelegation);
    1202
    1203
        /// Sign an EIP-7702 authorization for delegation
    1204
        function signDelegation(address implementation, uint256 privateKey)
    1205
            external
    1206
            returns (SignedDelegation memory signedDelegation);
    1207
    1208
        /// Sign an EIP-7702 authorization for delegation for specific nonce
    1209
        function signDelegation(address implementation, uint256 privateKey, uint64 nonce)
    1210
            external
    1211
            returns (SignedDelegation memory signedDelegation);
    1212
    1213
        /// Sign an EIP-7702 authorization for delegation, with optional cross-chain validity.
    1214
        function signDelegation(address implementation, uint256 privateKey, bool crossChain)
    1215
            external
    1216
            returns (SignedDelegation memory signedDelegation);
    1217
    1218
        /// Has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain.
    1219
        /// Broadcasting address is determined by checking the following in order:
    1220
        /// 1. If `--sender` argument was provided, that address is used.
    1221
        /// 2. If exactly one signer (e.g. private key, hw wallet, keystore) is set when `forge broadcast` is invoked, that signer is used.
    1222
        /// 3. Otherwise, default foundry sender (1804c8AB1F12E6bbf3894d4083f33e07309d1f38) is used.
    1223
        function startBroadcast() external;
    1224
    1225
        /// Has all subsequent calls (at this call depth only) create transactions with the address
    1226
        /// provided that can later be signed and sent onchain.
    1227
        function startBroadcast(address signer) external;
    1228
    1229
        /// Has all subsequent calls (at this call depth only) create transactions with the private key
    1230
        /// provided that can later be signed and sent onchain.
    1231
        function startBroadcast(uint256 privateKey) external;
    1232
    1233
        /// Stops collecting onchain transactions.
    1234
        function stopBroadcast() external;
    1235
    1236
        // ======== String ========
    1237
    1238
        /// Returns true if `search` is found in `subject`, false otherwise.
    1239
        function contains(string calldata subject, string calldata search) external pure returns (bool result);
    1240
    1241
        /// Returns the index of the first occurrence of a `key` in an `input` string.
    1242
        /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `key` is not found.
    1243
        /// Returns 0 in case of an empty `key`.
    1244
        function indexOf(string calldata input, string calldata key) external pure returns (uint256);
    1245
    1246
        /// Parses the given `string` into an `address`.
    1247
        function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);
    1248
    1249
        /// Parses the given `string` into a `bool`.
    1250
        function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
    1251
    1252
        /// Parses the given `string` into `bytes`.
    1253
        function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);
    1254
    1255
        /// Parses the given `string` into a `bytes32`.
    1256
        function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);
    1257
    1258
        /// Parses the given `string` into a `int256`.
    1259
        function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);
    1260
    1261
        /// Parses the given `string` into a `uint256`.
    1262
        function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);
    1263
    1264
        /// Replaces occurrences of `from` in the given `string` with `to`.
    1265
        function replace(string calldata input, string calldata from, string calldata to)
    1266
            external
    1267
            pure
    1268
            returns (string memory output);
    1269
    1270
        /// Splits the given `string` into an array of strings divided by the `delimiter`.
    1271
        function split(string calldata input, string calldata delimiter) external pure returns (string[] memory outputs);
    1272
    1273
        /// Converts the given `string` value to Lowercase.
    1274
        function toLowercase(string calldata input) external pure returns (string memory output);
    1275
    1276
        /// Converts the given value to a `string`.
    1277
        function toString(address value) external pure returns (string memory stringifiedValue);
    1278
    1279
        /// Converts the given value to a `string`.
    1280
        function toString(bytes calldata value) external pure returns (string memory stringifiedValue);
    1281
    1282
        /// Converts the given value to a `string`.
    1283
        function toString(bytes32 value) external pure returns (string memory stringifiedValue);
    1284
    1285
        /// Converts the given value to a `string`.
    1286
        function toString(bool value) external pure returns (string memory stringifiedValue);
    1287
    1288
        /// Converts the given value to a `string`.
    1289
        function toString(uint256 value) external pure returns (string memory stringifiedValue);
    1290
    1291
        /// Converts the given value to a `string`.
    1292
        function toString(int256 value) external pure returns (string memory stringifiedValue);
    1293
    1294
        /// Converts the given `string` value to Uppercase.
    1295
        function toUppercase(string calldata input) external pure returns (string memory output);
    1296
    1297
        /// Trims leading and trailing whitespace from the given `string` value.
    1298
        function trim(string calldata input) external pure returns (string memory output);
    1299
    1300
        // ======== Testing ========
    1301
    1302
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1303
        /// Formats values with decimals in failure message.
    1304
        function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) external pure;
    1305
    1306
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1307
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1308
        function assertApproxEqAbsDecimal(
    1309
            uint256 left,
    1310
            uint256 right,
    1311
            uint256 maxDelta,
    1312
            uint256 decimals,
    1313
            string calldata error
    1314
        ) external pure;
    1315
    1316
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1317
        /// Formats values with decimals in failure message.
    1318
        function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) external pure;
    1319
    1320
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1321
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1322
        function assertApproxEqAbsDecimal(
    1323
            int256 left,
    1324
            int256 right,
    1325
            uint256 maxDelta,
    1326
            uint256 decimals,
    1327
            string calldata error
    1328
        ) external pure;
    1329
    1330
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1331
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) external pure;
    1332
    1333
        /// Compares two `uint256` values. Expects difference to be less than or equal to `maxDelta`.
    1334
        /// Includes error message into revert string on failure.
    1335
        function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string calldata error) external pure;
    1336
    1337
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1338
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) external pure;
    1339
    1340
        /// Compares two `int256` values. Expects difference to be less than or equal to `maxDelta`.
    1341
        /// Includes error message into revert string on failure.
    1342
        function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string calldata error) external pure;
    1343
    1344
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1345
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1346
        /// Formats values with decimals in failure message.
    1347
        function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals)
    1348
            external
    1349
            pure;
    1350
    1351
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1352
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1353
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1354
        function assertApproxEqRelDecimal(
    1355
            uint256 left,
    1356
            uint256 right,
    1357
            uint256 maxPercentDelta,
    1358
            uint256 decimals,
    1359
            string calldata error
    1360
        ) external pure;
    1361
    1362
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1363
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1364
        /// Formats values with decimals in failure message.
    1365
        function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals)
    1366
            external
    1367
            pure;
    1368
    1369
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1370
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1371
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1372
        function assertApproxEqRelDecimal(
    1373
            int256 left,
    1374
            int256 right,
    1375
            uint256 maxPercentDelta,
    1376
            uint256 decimals,
    1377
            string calldata error
    1378
        ) external pure;
    1379
    1380
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1381
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1382
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) external pure;
    1383
    1384
        /// Compares two `uint256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1385
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1386
        /// Includes error message into revert string on failure.
    1387
        function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string calldata error)
    1388
            external
    1389
            pure;
    1390
    1391
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1392
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1393
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) external pure;
    1394
    1395
        /// Compares two `int256` values. Expects relative difference in percents to be less than or equal to `maxPercentDelta`.
    1396
        /// `maxPercentDelta` is an 18 decimal fixed point number, where 1e18 == 100%
    1397
        /// Includes error message into revert string on failure.
    1398
        function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string calldata error) external pure;
    1399
    1400
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1401
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1402
    1403
        /// Asserts that two `uint256` values are equal, formatting them with decimals in failure message.
    1404
        /// Includes error message into revert string on failure.
    1405
        function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1406
    1407
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1408
        function assertEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1409
    1410
        /// Asserts that two `int256` values are equal, formatting them with decimals in failure message.
    1411
        /// Includes error message into revert string on failure.
    1412
        function assertEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1413
    1414
        /// Asserts that two `bool` values are equal.
    1415
        function assertEq(bool left, bool right) external pure;
    1416
    1417
        /// Asserts that two `bool` values are equal and includes error message into revert string on failure.
    1418
        function assertEq(bool left, bool right, string calldata error) external pure;
    1419
    1420
        /// Asserts that two `string` values are equal.
    1421
        function assertEq(string calldata left, string calldata right) external pure;
    1422
    1423
        /// Asserts that two `string` values are equal and includes error message into revert string on failure.
    1424
        function assertEq(string calldata left, string calldata right, string calldata error) external pure;
    1425
    1426
        /// Asserts that two `bytes` values are equal.
    1427
        function assertEq(bytes calldata left, bytes calldata right) external pure;
    1428
    1429
        /// Asserts that two `bytes` values are equal and includes error message into revert string on failure.
    1430
        function assertEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1431
    1432
        /// Asserts that two arrays of `bool` values are equal.
    1433
        function assertEq(bool[] calldata left, bool[] calldata right) external pure;
    1434
    1435
        /// Asserts that two arrays of `bool` values are equal and includes error message into revert string on failure.
    1436
        function assertEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1437
    1438
        /// Asserts that two arrays of `uint256 values are equal.
    1439
        function assertEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1440
    1441
        /// Asserts that two arrays of `uint256` values are equal and includes error message into revert string on failure.
    1442
        function assertEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1443
    1444
        /// Asserts that two arrays of `int256` values are equal.
    1445
        function assertEq(int256[] calldata left, int256[] calldata right) external pure;
    1446
    1447
        /// Asserts that two arrays of `int256` values are equal and includes error message into revert string on failure.
    1448
        function assertEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1449
    1450
        /// Asserts that two `uint256` values are equal.
    1451
        function assertEq(uint256 left, uint256 right) external pure;
    1452
    1453
        /// Asserts that two arrays of `address` values are equal.
    1454
        function assertEq(address[] calldata left, address[] calldata right) external pure;
    1455
    1456
        /// Asserts that two arrays of `address` values are equal and includes error message into revert string on failure.
    1457
        function assertEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1458
    1459
        /// Asserts that two arrays of `bytes32` values are equal.
    1460
        function assertEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1461
    1462
        /// Asserts that two arrays of `bytes32` values are equal and includes error message into revert string on failure.
    1463
        function assertEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1464
    1465
        /// Asserts that two arrays of `string` values are equal.
    1466
        function assertEq(string[] calldata left, string[] calldata right) external pure;
    1467
    1468
        /// Asserts that two arrays of `string` values are equal and includes error message into revert string on failure.
    1469
        function assertEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1470
    1471
        /// Asserts that two arrays of `bytes` values are equal.
    1472
        function assertEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1473
    1474
        /// Asserts that two arrays of `bytes` values are equal and includes error message into revert string on failure.
    1475
        function assertEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1476
    1477
        /// Asserts that two `uint256` values are equal and includes error message into revert string on failure.
    1478
        function assertEq(uint256 left, uint256 right, string calldata error) external pure;
    1479
    1480
        /// Asserts that two `int256` values are equal.
    1481
        function assertEq(int256 left, int256 right) external pure;
    1482
    1483
        /// Asserts that two `int256` values are equal and includes error message into revert string on failure.
    1484
        function assertEq(int256 left, int256 right, string calldata error) external pure;
    1485
    1486
        /// Asserts that two `address` values are equal.
    1487
        function assertEq(address left, address right) external pure;
    1488
    1489
        /// Asserts that two `address` values are equal and includes error message into revert string on failure.
    1490
        function assertEq(address left, address right, string calldata error) external pure;
    1491
    1492
        /// Asserts that two `bytes32` values are equal.
    1493
        function assertEq(bytes32 left, bytes32 right) external pure;
    1494
    1495
        /// Asserts that two `bytes32` values are equal and includes error message into revert string on failure.
    1496
        function assertEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1497
    1498
        /// Asserts that the given condition is false.
    1499
        function assertFalse(bool condition) external pure;
    1500
    1501
        /// Asserts that the given condition is false and includes error message into revert string on failure.
    1502
        function assertFalse(bool condition, string calldata error) external pure;
    1503
    1504
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1505
        /// Formats values with decimals in failure message.
    1506
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1507
    1508
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1509
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1510
        function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1511
    1512
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1513
        /// Formats values with decimals in failure message.
    1514
        function assertGeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1515
    1516
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1517
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1518
        function assertGeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1519
    1520
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1521
        function assertGe(uint256 left, uint256 right) external pure;
    1522
    1523
        /// Compares two `uint256` values. Expects first value to be greater than or equal to second.
    1524
        /// Includes error message into revert string on failure.
    1525
        function assertGe(uint256 left, uint256 right, string calldata error) external pure;
    1526
    1527
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1528
        function assertGe(int256 left, int256 right) external pure;
    1529
    1530
        /// Compares two `int256` values. Expects first value to be greater than or equal to second.
    1531
        /// Includes error message into revert string on failure.
    1532
        function assertGe(int256 left, int256 right, string calldata error) external pure;
    1533
    1534
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1535
        /// Formats values with decimals in failure message.
    1536
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1537
    1538
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1539
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1540
        function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1541
    1542
        /// Compares two `int256` values. Expects first value to be greater than second.
    1543
        /// Formats values with decimals in failure message.
    1544
        function assertGtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1545
    1546
        /// Compares two `int256` values. Expects first value to be greater than second.
    1547
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1548
        function assertGtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1549
    1550
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1551
        function assertGt(uint256 left, uint256 right) external pure;
    1552
    1553
        /// Compares two `uint256` values. Expects first value to be greater than second.
    1554
        /// Includes error message into revert string on failure.
    1555
        function assertGt(uint256 left, uint256 right, string calldata error) external pure;
    1556
    1557
        /// Compares two `int256` values. Expects first value to be greater than second.
    1558
        function assertGt(int256 left, int256 right) external pure;
    1559
    1560
        /// Compares two `int256` values. Expects first value to be greater than second.
    1561
        /// Includes error message into revert string on failure.
    1562
        function assertGt(int256 left, int256 right, string calldata error) external pure;
    1563
    1564
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1565
        /// Formats values with decimals in failure message.
    1566
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1567
    1568
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1569
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1570
        function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1571
    1572
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1573
        /// Formats values with decimals in failure message.
    1574
        function assertLeDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1575
    1576
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1577
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1578
        function assertLeDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1579
    1580
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1581
        function assertLe(uint256 left, uint256 right) external pure;
    1582
    1583
        /// Compares two `uint256` values. Expects first value to be less than or equal to second.
    1584
        /// Includes error message into revert string on failure.
    1585
        function assertLe(uint256 left, uint256 right, string calldata error) external pure;
    1586
    1587
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1588
        function assertLe(int256 left, int256 right) external pure;
    1589
    1590
        /// Compares two `int256` values. Expects first value to be less than or equal to second.
    1591
        /// Includes error message into revert string on failure.
    1592
        function assertLe(int256 left, int256 right, string calldata error) external pure;
    1593
    1594
        /// Compares two `uint256` values. Expects first value to be less than second.
    1595
        /// Formats values with decimals in failure message.
    1596
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1597
    1598
        /// Compares two `uint256` values. Expects first value to be less than second.
    1599
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1600
        function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1601
    1602
        /// Compares two `int256` values. Expects first value to be less than second.
    1603
        /// Formats values with decimals in failure message.
    1604
        function assertLtDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1605
    1606
        /// Compares two `int256` values. Expects first value to be less than second.
    1607
        /// Formats values with decimals in failure message. Includes error message into revert string on failure.
    1608
        function assertLtDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1609
    1610
        /// Compares two `uint256` values. Expects first value to be less than second.
    1611
        function assertLt(uint256 left, uint256 right) external pure;
    1612
    1613
        /// Compares two `uint256` values. Expects first value to be less than second.
    1614
        /// Includes error message into revert string on failure.
    1615
        function assertLt(uint256 left, uint256 right, string calldata error) external pure;
    1616
    1617
        /// Compares two `int256` values. Expects first value to be less than second.
    1618
        function assertLt(int256 left, int256 right) external pure;
    1619
    1620
        /// Compares two `int256` values. Expects first value to be less than second.
    1621
        /// Includes error message into revert string on failure.
    1622
        function assertLt(int256 left, int256 right, string calldata error) external pure;
    1623
    1624
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1625
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) external pure;
    1626
    1627
        /// Asserts that two `uint256` values are not equal, formatting them with decimals in failure message.
    1628
        /// Includes error message into revert string on failure.
    1629
        function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string calldata error) external pure;
    1630
    1631
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1632
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) external pure;
    1633
    1634
        /// Asserts that two `int256` values are not equal, formatting them with decimals in failure message.
    1635
        /// Includes error message into revert string on failure.
    1636
        function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string calldata error) external pure;
    1637
    1638
        /// Asserts that two `bool` values are not equal.
    1639
        function assertNotEq(bool left, bool right) external pure;
    1640
    1641
        /// Asserts that two `bool` values are not equal and includes error message into revert string on failure.
    1642
        function assertNotEq(bool left, bool right, string calldata error) external pure;
    1643
    1644
        /// Asserts that two `string` values are not equal.
    1645
        function assertNotEq(string calldata left, string calldata right) external pure;
    1646
    1647
        /// Asserts that two `string` values are not equal and includes error message into revert string on failure.
    1648
        function assertNotEq(string calldata left, string calldata right, string calldata error) external pure;
    1649
    1650
        /// Asserts that two `bytes` values are not equal.
    1651
        function assertNotEq(bytes calldata left, bytes calldata right) external pure;
    1652
    1653
        /// Asserts that two `bytes` values are not equal and includes error message into revert string on failure.
    1654
        function assertNotEq(bytes calldata left, bytes calldata right, string calldata error) external pure;
    1655
    1656
        /// Asserts that two arrays of `bool` values are not equal.
    1657
        function assertNotEq(bool[] calldata left, bool[] calldata right) external pure;
    1658
    1659
        /// Asserts that two arrays of `bool` values are not equal and includes error message into revert string on failure.
    1660
        function assertNotEq(bool[] calldata left, bool[] calldata right, string calldata error) external pure;
    1661
    1662
        /// Asserts that two arrays of `uint256` values are not equal.
    1663
        function assertNotEq(uint256[] calldata left, uint256[] calldata right) external pure;
    1664
    1665
        /// Asserts that two arrays of `uint256` values are not equal and includes error message into revert string on failure.
    1666
        function assertNotEq(uint256[] calldata left, uint256[] calldata right, string calldata error) external pure;
    1667
    1668
        /// Asserts that two arrays of `int256` values are not equal.
    1669
        function assertNotEq(int256[] calldata left, int256[] calldata right) external pure;
    1670
    1671
        /// Asserts that two arrays of `int256` values are not equal and includes error message into revert string on failure.
    1672
        function assertNotEq(int256[] calldata left, int256[] calldata right, string calldata error) external pure;
    1673
    1674
        /// Asserts that two `uint256` values are not equal.
    1675
        function assertNotEq(uint256 left, uint256 right) external pure;
    1676
    1677
        /// Asserts that two arrays of `address` values are not equal.
    1678
        function assertNotEq(address[] calldata left, address[] calldata right) external pure;
    1679
    1680
        /// Asserts that two arrays of `address` values are not equal and includes error message into revert string on failure.
    1681
        function assertNotEq(address[] calldata left, address[] calldata right, string calldata error) external pure;
    1682
    1683
        /// Asserts that two arrays of `bytes32` values are not equal.
    1684
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right) external pure;
    1685
    1686
        /// Asserts that two arrays of `bytes32` values are not equal and includes error message into revert string on failure.
    1687
        function assertNotEq(bytes32[] calldata left, bytes32[] calldata right, string calldata error) external pure;
    1688
    1689
        /// Asserts that two arrays of `string` values are not equal.
    1690
        function assertNotEq(string[] calldata left, string[] calldata right) external pure;
    1691
    1692
        /// Asserts that two arrays of `string` values are not equal and includes error message into revert string on failure.
    1693
        function assertNotEq(string[] calldata left, string[] calldata right, string calldata error) external pure;
    1694
    1695
        /// Asserts that two arrays of `bytes` values are not equal.
    1696
        function assertNotEq(bytes[] calldata left, bytes[] calldata right) external pure;
    1697
    1698
        /// Asserts that two arrays of `bytes` values are not equal and includes error message into revert string on failure.
    1699
        function assertNotEq(bytes[] calldata left, bytes[] calldata right, string calldata error) external pure;
    1700
    1701
        /// Asserts that two `uint256` values are not equal and includes error message into revert string on failure.
    1702
        function assertNotEq(uint256 left, uint256 right, string calldata error) external pure;
    1703
    1704
        /// Asserts that two `int256` values are not equal.
    1705
        function assertNotEq(int256 left, int256 right) external pure;
    1706
    1707
        /// Asserts that two `int256` values are not equal and includes error message into revert string on failure.
    1708
        function assertNotEq(int256 left, int256 right, string calldata error) external pure;
    1709
    1710
        /// Asserts that two `address` values are not equal.
    1711
        function assertNotEq(address left, address right) external pure;
    1712
    1713
        /// Asserts that two `address` values are not equal and includes error message into revert string on failure.
    1714
        function assertNotEq(address left, address right, string calldata error) external pure;
    1715
    1716
        /// Asserts that two `bytes32` values are not equal.
    1717
        function assertNotEq(bytes32 left, bytes32 right) external pure;
    1718
    1719
        /// Asserts that two `bytes32` values are not equal and includes error message into revert string on failure.
    1720
        function assertNotEq(bytes32 left, bytes32 right, string calldata error) external pure;
    1721
    1722
        /// Asserts that the given condition is true.
    1723
        function assertTrue(bool condition) external pure;
    1724
    1725
        /// Asserts that the given condition is true and includes error message into revert string on failure.
    1726
        function assertTrue(bool condition, string calldata error) external pure;
    1727
    1728
        /// If the condition is false, discard this run's fuzz inputs and generate new ones.
    1729
        function assume(bool condition) external pure;
    1730
    1731
        /// Discard this run's fuzz inputs and generate new ones if next call reverted.
    1732
        function assumeNoRevert() external pure;
    1733
    1734
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the potential revert parameters.
    1735
        function assumeNoRevert(PotentialRevert calldata potentialRevert) external pure;
    1736
    1737
        /// Discard this run's fuzz inputs and generate new ones if next call reverts with the any of the potential revert parameters.
    1738
        function assumeNoRevert(PotentialRevert[] calldata potentialReverts) external pure;
    1739
    1740
        /// Writes a breakpoint to jump to in the debugger.
    1741
        function breakpoint(string calldata char) external pure;
    1742
    1743
        /// Writes a conditional breakpoint to jump to in the debugger.
    1744
        function breakpoint(string calldata char, bool value) external pure;
    1745
    1746
        /// Returns true if the current Foundry version is greater than or equal to the given version.
    1747
        /// The given version string must be in the format `major.minor.patch`.
    1748
        /// This is equivalent to `foundryVersionCmp(version) >= 0`.
    1749
        function foundryVersionAtLeast(string calldata version) external view returns (bool);
    1750
    1751
        /// Compares the current Foundry version with the given version string.
    1752
        /// The given version string must be in the format `major.minor.patch`.
    1753
        /// Returns:
    1754
        /// -1 if current Foundry version is less than the given version
    1755
        /// 0 if current Foundry version equals the given version
    1756
        /// 1 if current Foundry version is greater than the given version
    1757
        /// This result can then be used with a comparison operator against `0`.
    1758
        /// For example, to check if the current Foundry version is greater than or equal to `1.0.0`:
    1759
        /// `if (foundryVersionCmp("1.0.0") >= 0) { ... }`
    1760
        function foundryVersionCmp(string calldata version) external view returns (int256);
    1761
    1762
        /// Returns a Chain struct for specific alias
    1763
        function getChain(string calldata chainAlias) external view returns (Chain memory chain);
    1764
    1765
        /// Returns a Chain struct for specific chainId
    1766
        function getChain(uint256 chainId) external view returns (Chain memory chain);
    1767
    1768
        /// Returns the Foundry version.
    1769
        /// Format: <cargo_version>-<tag>+<git_sha_short>.<unix_build_timestamp>.<profile>
    1770
        /// Sample output: 0.3.0-nightly+3cb96bde9b.1737036656.debug
    1771
        /// Note: Build timestamps may vary slightly across platforms due to separate CI jobs.
    1772
        /// For reliable version comparisons, use UNIX format (e.g., >= 1700000000)
    1773
        /// to compare timestamps while ignoring minor time differences.
    1774
        function getFoundryVersion() external view returns (string memory version);
    1775
    1776
        /// Returns the RPC url for the given alias.
    1777
        function rpcUrl(string calldata rpcAlias) external view returns (string memory json);
    1778
    1779
        /// Returns all rpc urls and their aliases as structs.
    1780
        function rpcUrlStructs() external view returns (Rpc[] memory urls);
    1781
    1782
        /// Returns all rpc urls and their aliases `[alias, url][]`.
    1783
        function rpcUrls() external view returns (string[2][] memory urls);
    1784
    1785
        /// Suspends execution of the main thread for `duration` milliseconds.
    1786
        function sleep(uint256 duration) external;
    1787
    1788
        // ======== Toml ========
    1789
    1790
        /// Checks if `key` exists in a TOML table.
    1791
        function keyExistsToml(string calldata toml, string calldata key) external view returns (bool);
    1792
    1793
        /// Parses a string of TOML data at `key` and coerces it to `address`.
    1794
        function parseTomlAddress(string calldata toml, string calldata key) external pure returns (address);
    1795
    1796
        /// Parses a string of TOML data at `key` and coerces it to `address[]`.
    1797
        function parseTomlAddressArray(string calldata toml, string calldata key) external pure returns (address[] memory);
    1798
    1799
        /// Parses a string of TOML data at `key` and coerces it to `bool`.
    1800
        function parseTomlBool(string calldata toml, string calldata key) external pure returns (bool);
    1801
    1802
        /// Parses a string of TOML data at `key` and coerces it to `bool[]`.
    1803
        function parseTomlBoolArray(string calldata toml, string calldata key) external pure returns (bool[] memory);
    1804
    1805
        /// Parses a string of TOML data at `key` and coerces it to `bytes`.
    1806
        function parseTomlBytes(string calldata toml, string calldata key) external pure returns (bytes memory);
    1807
    1808
        /// Parses a string of TOML data at `key` and coerces it to `bytes32`.
    1809
        function parseTomlBytes32(string calldata toml, string calldata key) external pure returns (bytes32);
    1810
    1811
        /// Parses a string of TOML data at `key` and coerces it to `bytes32[]`.
    1812
        function parseTomlBytes32Array(string calldata toml, string calldata key) external pure returns (bytes32[] memory);
    1813
    1814
        /// Parses a string of TOML data at `key` and coerces it to `bytes[]`.
    1815
        function parseTomlBytesArray(string calldata toml, string calldata key) external pure returns (bytes[] memory);
    1816
    1817
        /// Parses a string of TOML data at `key` and coerces it to `int256`.
    1818
        function parseTomlInt(string calldata toml, string calldata key) external pure returns (int256);
    1819
    1820
        /// Parses a string of TOML data at `key` and coerces it to `int256[]`.
    1821
        function parseTomlIntArray(string calldata toml, string calldata key) external pure returns (int256[] memory);
    1822
    1823
        /// Returns an array of all the keys in a TOML table.
    1824
        function parseTomlKeys(string calldata toml, string calldata key) external pure returns (string[] memory keys);
    1825
    1826
        /// Parses a string of TOML data at `key` and coerces it to `string`.
    1827
        function parseTomlString(string calldata toml, string calldata key) external pure returns (string memory);
    1828
    1829
        /// Parses a string of TOML data at `key` and coerces it to `string[]`.
    1830
        function parseTomlStringArray(string calldata toml, string calldata key) external pure returns (string[] memory);
    1831
    1832
        /// Parses a string of TOML data at `key` and coerces it to type array corresponding to `typeDescription`.
    1833
        function parseTomlTypeArray(string calldata toml, string calldata key, string calldata typeDescription)
    1834
            external
    1835
            pure
    1836
            returns (bytes memory);
    1837
    1838
        /// Parses a string of TOML data and coerces it to type corresponding to `typeDescription`.
    1839
        function parseTomlType(string calldata toml, string calldata typeDescription) external pure returns (bytes memory);
    1840
    1841
        /// Parses a string of TOML data at `key` and coerces it to type corresponding to `typeDescription`.
    1842
        function parseTomlType(string calldata toml, string calldata key, string calldata typeDescription)
    1843
            external
    1844
            pure
    1845
            returns (bytes memory);
    1846
    1847
        /// Parses a string of TOML data at `key` and coerces it to `uint256`.
    1848
        function parseTomlUint(string calldata toml, string calldata key) external pure returns (uint256);
    1849
    1850
        /// Parses a string of TOML data at `key` and coerces it to `uint256[]`.
    1851
        function parseTomlUintArray(string calldata toml, string calldata key) external pure returns (uint256[] memory);
    1852
    1853
        /// ABI-encodes a TOML table.
    1854
        function parseToml(string calldata toml) external pure returns (bytes memory abiEncodedData);
    1855
    1856
        /// ABI-encodes a TOML table at `key`.
    1857
        function parseToml(string calldata toml, string calldata key) external pure returns (bytes memory abiEncodedData);
    1858
    1859
        /// Takes serialized JSON, converts to TOML and write a serialized TOML to a file.
    1860
        function writeToml(string calldata json, string calldata path) external;
    1861
    1862
        /// Takes serialized JSON, converts to TOML and write a serialized TOML table to an **existing** TOML file, replacing a value with key = <value_key.>
    1863
        /// This is useful to replace a specific value of a TOML file, without having to parse the entire thing.
    1864
        /// This cheatcode will create new keys if they didn't previously exist.
    1865
        function writeToml(string calldata json, string calldata path, string calldata valueKey) external;
    1866
    1867
        // ======== Utilities ========
    1868
    1869
        /// Returns an uint256 value bounded in given range and different from the current one.
    1870
        function bound(uint256 current, uint256 min, uint256 max) external view returns (uint256);
    1871
    1872
        /// Returns an int256 value bounded in given range and different from the current one.
    1873
        function bound(int256 current, int256 min, int256 max) external view returns (int256);
    1874
    1875
        /// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.
    1876
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) external pure returns (address);
    1877
    1878
        /// Compute the address of a contract created with CREATE2 using the default CREATE2 deployer.
    1879
        function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);
    1880
    1881
        /// Compute the address a contract will be deployed at for a given deployer address and nonce.
    1882
        function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);
    1883
    1884
        /// Utility cheatcode to copy storage of `from` contract to another `to` contract.
    1885
        function copyStorage(address from, address to) external;
    1886
    1887
        /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
    1888
        /// Supports 2 different inputs:
    1889
        /// 1. Name of the type (i.e. "PermitSingle"):
    1890
        /// * requires previous binding generation with `forge bind-json`.
    1891
        /// * bindings will be retrieved from the path configured in `foundry.toml`.
    1892
        /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
    1893
        /// * Note: the cheatcode will use the canonical type even if the input is malformated
    1894
        /// with the wrong order of elements or with extra whitespaces.
    1895
        function eip712HashStruct(string calldata typeNameOrDefinition, bytes calldata abiEncodedData)
    1896
            external
    1897
            pure
    1898
            returns (bytes32 typeHash);
    1899
    1900
        /// Generates the struct hash of the canonical EIP-712 type representation and its abi-encoded data.
    1901
        /// Requires previous binding generation with `forge bind-json`.
    1902
        /// Params:
    1903
        /// * `bindingsPath`: path where the output of `forge bind-json` is stored.
    1904
        /// * `typeName`: Name of the type (i.e. "PermitSingle").
    1905
        /// * `abiEncodedData`: ABI-encoded data for the struct that is being hashed.
    1906
        function eip712HashStruct(string calldata bindingsPath, string calldata typeName, bytes calldata abiEncodedData)
    1907
            external
    1908
            pure
    1909
            returns (bytes32 typeHash);
    1910
    1911
        /// Generates the hash of the canonical EIP-712 type representation.
    1912
        /// Supports 2 different inputs:
    1913
        /// 1. Name of the type (i.e. "Transaction"):
    1914
        /// * requires previous binding generation with `forge bind-json`.
    1915
        /// * bindings will be retrieved from the path configured in `foundry.toml`.
    1916
        /// 2. String representation of the type (i.e. "Foo(Bar bar) Bar(uint256 baz)").
    1917
        /// * Note: the cheatcode will output the canonical type even if the input is malformated
    1918
        /// with the wrong order of elements or with extra whitespaces.
    1919
        function eip712HashType(string calldata typeNameOrDefinition) external pure returns (bytes32 typeHash);
    1920
    1921
        /// Generates the hash of the canonical EIP-712 type representation.
    1922
        /// Requires previous binding generation with `forge bind-json`.
    1923
        /// Params:
    1924
        /// * `bindingsPath`: path where the output of `forge bind-json` is stored.
    1925
        /// * `typeName`: Name of the type (i.e. "Transaction").
    1926
        function eip712HashType(string calldata bindingsPath, string calldata typeName)
    1927
            external
    1928
            pure
    1929
            returns (bytes32 typeHash);
    1930
    1931
        /// Generates a ready-to-sign digest of human-readable typed data following the EIP-712 standard.
    1932
        function eip712HashTypedData(string calldata jsonData) external pure returns (bytes32 digest);
    1933
    1934
        /// Returns ENS namehash for provided string.
    1935
        function ensNamehash(string calldata name) external pure returns (bytes32);
    1936
    1937
        /// RLP decodes an RLP payload into a list of bytes.
    1938
        function fromRlp(bytes calldata rlp) external pure returns (bytes[] memory data);
    1939
    1940
        /// Gets the label for the specified address.
    1941
        function getLabel(address account) external view returns (string memory currentLabel);
    1942
    1943
        /// Labels an address in call traces.
    1944
        function label(address account, string calldata newLabel) external;
    1945
    1946
        /// Pauses collection of call traces. Useful in cases when you want to skip tracing of
    1947
        /// complex calls which are not useful for debugging.
    1948
        function pauseTracing() external view;
    1949
    1950
        /// Returns a random `address`.
    1951
        function randomAddress() external view returns (address);
    1952
    1953
        /// Returns a random `bool`.
    1954
        function randomBool() external view returns (bool);
    1955
    1956
        /// Returns a random byte array value of the given length.
    1957
        function randomBytes(uint256 len) external view returns (bytes memory);
    1958
    1959
        /// Returns a random fixed-size byte array of length 4.
    1960
        function randomBytes4() external view returns (bytes4);
    1961
    1962
        /// Returns a random fixed-size byte array of length 8.
    1963
        function randomBytes8() external view returns (bytes8);
    1964
    1965
        /// Returns a random `int256` value.
    1966
        function randomInt() external view returns (int256);
    1967
    1968
        /// Returns a random `int256` value of given bits.
    1969
        function randomInt(uint256 bits) external view returns (int256);
    1970
    1971
        /// Returns a random uint256 value.
    1972
        function randomUint() external view returns (uint256);
    1973
    1974
        /// Returns random uint256 value between the provided range (=min..=max).
    1975
        function randomUint(uint256 min, uint256 max) external view returns (uint256);
    1976
    1977
        /// Returns a random `uint256` value of given bits.
    1978
        function randomUint(uint256 bits) external view returns (uint256);
    1979
    1980
        /// Unpauses collection of call traces.
    1981
        function resumeTracing() external view;
    1982
    1983
        /// Utility cheatcode to set arbitrary storage for given target address.
    1984
        function setArbitraryStorage(address target) external;
    1985
    1986
        /// Utility cheatcode to set arbitrary storage for given target address and overwrite
    1987
        /// any storage slots that have been previously set.
    1988
        function setArbitraryStorage(address target, bool overwrite) external;
    1989
    1990
        /// Set RNG seed.
    1991
        function setSeed(uint256 seed) external;
    1992
    1993
        /// Randomly shuffles an array.
    1994
        function shuffle(uint256[] calldata array) external returns (uint256[] memory);
    1995
    1996
        /// Sorts an array in ascending order.
    1997
        function sort(uint256[] calldata array) external returns (uint256[] memory);
    1998
    1999
        /// Encodes a `bytes` value to a base64url string.
    2000
        function toBase64URL(bytes calldata data) external pure returns (string memory);
    2001
    2002
        /// Encodes a `string` value to a base64url string.
    2003
        function toBase64URL(string calldata data) external pure returns (string memory);
    2004
    2005
        /// Encodes a `bytes` value to a base64 string.
    2006
        function toBase64(bytes calldata data) external pure returns (string memory);
    2007
    2008
        /// Encodes a `string` value to a base64 string.
    2009
        function toBase64(string calldata data) external pure returns (string memory);
    2010
    2011
        /// RLP encodes a list of bytes into an RLP payload.
    2012
        function toRlp(bytes[] calldata data) external pure returns (bytes memory);
    2013
    }
    2014
    2015
    /// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
    2016
    /// in tests, but it is not recommended to use these cheats in scripts.
    2017
    interface Vm is VmSafe {
    2018
        // ======== EVM ========
    2019
    2020
        /// Utility cheatcode to set an EIP-2930 access list for all subsequent transactions.
    2021
        function accessList(AccessListItem[] calldata access) external;
    2022
    2023
        /// Returns the identifier of the currently active fork. Reverts if no fork is currently active.
    2024
        function activeFork() external view returns (uint256 forkId);
    2025
    2026
        /// In forking mode, explicitly grant the given address cheatcode access.
    2027
        function allowCheatcodes(address account) external;
    2028
    2029
        /// Sets `block.blobbasefee`
    2030
        function blobBaseFee(uint256 newBlobBaseFee) external;
    2031
    2032
        /// Sets the blobhashes in the transaction.
    2033
        /// Not available on EVM versions before Cancun.
    2034
        /// If used on unsupported EVM versions it will revert.
    2035
        function blobhashes(bytes32[] calldata hashes) external;
    2036
    2037
        /// Sets `block.chainid`.
    2038
        function chainId(uint256 newChainId) external;
    2039
    2040
        /// Clears all mocked calls.
    2041
        function clearMockedCalls() external;
    2042
    2043
        /// Clones a source account code, state, balance and nonce to a target account and updates in-memory EVM state.
    2044
        function cloneAccount(address source, address target) external;
    2045
    2046
        /// Sets `block.coinbase`.
    2047
        function coinbase(address newCoinbase) external;
    2048
    2049
        /// Marks the slots of an account and the account address as cold.
    2050
        function cool(address target) external;
    2051
    2052
        /// Utility cheatcode to mark specific storage slot as cold, simulating no prior read.
    2053
        function coolSlot(address target, bytes32 slot) external;
    2054
    2055
        /// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork.
    2056
        function createFork(string calldata urlOrAlias) external returns (uint256 forkId);
    2057
    2058
        /// Creates a new fork with the given endpoint and block and returns the identifier of the fork.
    2059
        function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    2060
    2061
        /// Creates a new fork with the given endpoint and at the block the given transaction was mined in,
    2062
        /// replays all transaction mined in the block before the transaction, and returns the identifier of the fork.
    2063
        function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    2064
    2065
        /// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork.
    2066
        function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);
    2067
    2068
        /// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork.
    2069
        function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
    2070
    2071
        /// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in,
    2072
        /// replays all transaction mined in the block before the transaction, returns the identifier of the fork.
    2073
        function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
    2074
    2075
        /// Sets an address' balance.
    2076
        function deal(address account, uint256 newBalance) external;
    2077
    2078
        /// Removes the snapshot with the given ID created by `snapshot`.
    2079
        /// Takes the snapshot ID to delete.
    2080
        /// Returns `true` if the snapshot was successfully deleted.
    2081
        /// Returns `false` if the snapshot does not exist.
    2082
        function deleteStateSnapshot(uint256 snapshotId) external returns (bool success);
    2083
    2084
        /// Removes _all_ snapshots previously created by `snapshot`.
    2085
        function deleteStateSnapshots() external;
    2086
    2087
        /// Sets `block.difficulty`.
    2088
        /// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.
    2089
        /// Reverts if used on unsupported EVM versions.
    2090
        function difficulty(uint256 newDifficulty) external;
    2091
    2092
        /// Dump a genesis JSON file's `allocs` to disk.
    2093
        function dumpState(string calldata pathToStateJson) external;
    2094
    2095
        /// Sets an address' code.
    2096
        function etch(address target, bytes calldata newRuntimeBytecode) external;
    2097
    2098
        /// Sets `block.basefee`.
    2099
        function fee(uint256 newBasefee) external;
    2100
    2101
        /// Gets the blockhashes from the current transaction.
    2102
        /// Not available on EVM versions before Cancun.
    2103
        /// If used on unsupported EVM versions it will revert.
    2104
        function getBlobhashes() external view returns (bytes32[] memory hashes);
    2105
    2106
        /// Returns true if the account is marked as persistent.
    2107
        function isPersistent(address account) external view returns (bool persistent);
    2108
    2109
        /// Load a genesis JSON file's `allocs` into the in-memory EVM state.
    2110
        function loadAllocs(string calldata pathToAllocsJson) external;
    2111
    2112
        /// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
    2113
        /// Meaning, changes made to the state of this account will be kept when switching forks.
    2114
        function makePersistent(address account) external;
    2115
    2116
        /// See `makePersistent(address)`.
    2117
        function makePersistent(address account0, address account1) external;
    2118
    2119
        /// See `makePersistent(address)`.
    2120
        function makePersistent(address account0, address account1, address account2) external;
    2121
    2122
        /// See `makePersistent(address)`.
    2123
        function makePersistent(address[] calldata accounts) external;
    2124
    2125
        /// Reverts a call to an address with specified revert data.
    2126
        function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;
    2127
    2128
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    2129
        function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData) external;
    2130
    2131
        /// Reverts a call to an address with specified revert data.
    2132
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2133
        function mockCallRevert(address callee, bytes4 data, bytes calldata revertData) external;
    2134
    2135
        /// Reverts a call to an address with a specific `msg.value`, with specified revert data.
    2136
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2137
        function mockCallRevert(address callee, uint256 msgValue, bytes4 data, bytes calldata revertData) external;
    2138
    2139
        /// Mocks a call to an address, returning specified data.
    2140
        /// Calldata can either be strict or a partial match, e.g. if you only
    2141
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    2142
        /// function will be mocked.
    2143
        function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;
    2144
    2145
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    2146
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    2147
        function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;
    2148
    2149
        /// Mocks a call to an address, returning specified data.
    2150
        /// Calldata can either be strict or a partial match, e.g. if you only
    2151
        /// pass a Solidity selector to the expected calldata, then the entire Solidity
    2152
        /// function will be mocked.
    2153
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2154
        function mockCall(address callee, bytes4 data, bytes calldata returnData) external;
    2155
    2156
        /// Mocks a call to an address with a specific `msg.value`, returning specified data.
    2157
        /// Calldata match takes precedence over `msg.value` in case of ambiguity.
    2158
        /// Overload to pass the function selector directly `token.approve.selector` instead of `abi.encodeWithSelector(token.approve.selector)`.
    2159
        function mockCall(address callee, uint256 msgValue, bytes4 data, bytes calldata returnData) external;
    2160
    2161
        /// Mocks multiple calls to an address, returning specified data for each call.
    2162
        function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;
    2163
    2164
        /// Mocks multiple calls to an address with a specific `msg.value`, returning specified data for each call.
    2165
        function mockCalls(address callee, uint256 msgValue, bytes calldata data, bytes[] calldata returnData) external;
    2166
    2167
        /// Whenever a call is made to `callee` with calldata `data`, this cheatcode instead calls
    2168
        /// `target` with the same calldata. This functionality is similar to a delegate call made to
    2169
        /// `target` contract from `callee`.
    2170
        /// Can be used to substitute a call to a function with another implementation that captures
    2171
        /// the primary logic of the original function but is easier to reason about.
    2172
        /// If calldata is not a strict match then partial match by selector is attempted.
    2173
        function mockFunction(address callee, address target, bytes calldata data) external;
    2174
    2175
        /// Utility cheatcode to remove any EIP-2930 access list set by `accessList` cheatcode.
    2176
        function noAccessList() external;
    2177
    2178
        /// Sets the *next* call's `msg.sender` to be the input address.
    2179
        function prank(address msgSender) external;
    2180
    2181
        /// Sets the *next* call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    2182
        function prank(address msgSender, address txOrigin) external;
    2183
    2184
        /// Sets the *next* delegate call's `msg.sender` to be the input address.
    2185
        function prank(address msgSender, bool delegateCall) external;
    2186
    2187
        /// Sets the *next* delegate call's `msg.sender` to be the input address, and the `tx.origin` to be the second input.
    2188
        function prank(address msgSender, address txOrigin, bool delegateCall) external;
    2189
    2190
        /// Sets `block.prevrandao`.
    2191
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    2192
        /// If used on unsupported EVM versions it will revert.
    2193
        function prevrandao(bytes32 newPrevrandao) external;
    2194
    2195
        /// Sets `block.prevrandao`.
    2196
        /// Not available on EVM versions before Paris. Use `difficulty` instead.
    2197
        /// If used on unsupported EVM versions it will revert.
    2198
        function prevrandao(uint256 newPrevrandao) external;
    2199
    2200
        /// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification.
    2201
        function readCallers() external view returns (CallerMode callerMode, address msgSender, address txOrigin);
    2202
    2203
        /// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts.
    2204
        function resetNonce(address account) external;
    2205
    2206
        /// Revert the state of the EVM to a previous snapshot
    2207
        /// Takes the snapshot ID to revert to.
    2208
        /// Returns `true` if the snapshot was successfully reverted.
    2209
        /// Returns `false` if the snapshot does not exist.
    2210
        /// **Note:** This does not automatically delete the snapshot. To delete the snapshot use `deleteStateSnapshot`.
    2211
        function revertToState(uint256 snapshotId) external returns (bool success);
    2212
    2213
        /// Revert the state of the EVM to a previous snapshot and automatically deletes the snapshots
    2214
        /// Takes the snapshot ID to revert to.
    2215
        /// Returns `true` if the snapshot was successfully reverted and deleted.
    2216
        /// Returns `false` if the snapshot does not exist.
    2217
        function revertToStateAndDelete(uint256 snapshotId) external returns (bool success);
    2218
    2219
        /// Revokes persistent status from the address, previously added via `makePersistent`.
    2220
        function revokePersistent(address account) external;
    2221
    2222
        /// See `revokePersistent(address)`.
    2223
        function revokePersistent(address[] calldata accounts) external;
    2224
    2225
        /// Sets `block.height`.
    2226
        function roll(uint256 newHeight) external;
    2227
    2228
        /// Updates the currently active fork to given block number
    2229
        /// This is similar to `roll` but for the currently active fork.
    2230
        function rollFork(uint256 blockNumber) external;
    2231
    2232
        /// Updates the currently active fork to given transaction. This will `rollFork` with the number
    2233
        /// of the block the transaction was mined in and replays all transaction mined before it in the block.
    2234
        function rollFork(bytes32 txHash) external;
    2235
    2236
        /// Updates the given fork to given block number.
    2237
        function rollFork(uint256 forkId, uint256 blockNumber) external;
    2238
    2239
        /// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block.
    2240
        function rollFork(uint256 forkId, bytes32 txHash) external;
    2241
    2242
        /// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
    2243
        function selectFork(uint256 forkId) external;
    2244
    2245
        /// Set blockhash for the current block.
    2246
        /// It only sets the blockhash for blocks where `block.number - 256 <= number < block.number`.
    2247
        function setBlockhash(uint256 blockNumber, bytes32 blockHash) external;
    2248
    2249
        /// Sets the nonce of an account. Must be higher than the current nonce of the account.
    2250
        function setNonce(address account, uint64 newNonce) external;
    2251
    2252
        /// Sets the nonce of an account to an arbitrary value.
    2253
        function setNonceUnsafe(address account, uint64 newNonce) external;
    2254
    2255
        /// Snapshot capture the gas usage of the last call by name from the callee perspective.
    2256
        function snapshotGasLastCall(string calldata name) external returns (uint256 gasUsed);
    2257
    2258
        /// Snapshot capture the gas usage of the last call by name in a group from the callee perspective.
    2259
        function snapshotGasLastCall(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2260
    2261
        /// Snapshot the current state of the evm.
    2262
        /// Returns the ID of the snapshot that was created.
    2263
        /// To revert a snapshot use `revertToState`.
    2264
        function snapshotState() external returns (uint256 snapshotId);
    2265
    2266
        /// Snapshot capture an arbitrary numerical value by name.
    2267
        /// The group name is derived from the contract name.
    2268
        function snapshotValue(string calldata name, uint256 value) external;
    2269
    2270
        /// Snapshot capture an arbitrary numerical value by name in a group.
    2271
        function snapshotValue(string calldata group, string calldata name, uint256 value) external;
    2272
    2273
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called.
    2274
        function startPrank(address msgSender) external;
    2275
    2276
        /// Sets all subsequent calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2277
        function startPrank(address msgSender, address txOrigin) external;
    2278
    2279
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called.
    2280
        function startPrank(address msgSender, bool delegateCall) external;
    2281
    2282
        /// Sets all subsequent delegate calls' `msg.sender` to be the input address until `stopPrank` is called, and the `tx.origin` to be the second input.
    2283
        function startPrank(address msgSender, address txOrigin, bool delegateCall) external;
    2284
    2285
        /// Start a snapshot capture of the current gas usage by name.
    2286
        /// The group name is derived from the contract name.
    2287
        function startSnapshotGas(string calldata name) external;
    2288
    2289
        /// Start a snapshot capture of the current gas usage by name in a group.
    2290
        function startSnapshotGas(string calldata group, string calldata name) external;
    2291
    2292
        /// Resets subsequent calls' `msg.sender` to be `address(this)`.
    2293
        function stopPrank() external;
    2294
    2295
        /// Stop the snapshot capture of the current gas by latest snapshot name, capturing the gas used since the start.
    2296
        function stopSnapshotGas() external returns (uint256 gasUsed);
    2297
    2298
        /// Stop the snapshot capture of the current gas usage by name, capturing the gas used since the start.
    2299
        /// The group name is derived from the contract name.
    2300
        function stopSnapshotGas(string calldata name) external returns (uint256 gasUsed);
    2301
    2302
        /// Stop the snapshot capture of the current gas usage by name in a group, capturing the gas used since the start.
    2303
        function stopSnapshotGas(string calldata group, string calldata name) external returns (uint256 gasUsed);
    2304
    2305
        /// Stores a value to an address' storage slot.
    2306
        function store(address target, bytes32 slot, bytes32 value) external;
    2307
    2308
        /// Fetches the given transaction from the active fork and executes it on the current state.
    2309
        function transact(bytes32 txHash) external;
    2310
    2311
        /// Fetches the given transaction from the given fork and executes it on the current state.
    2312
        function transact(uint256 forkId, bytes32 txHash) external;
    2313
    2314
        /// Sets `tx.gasprice`.
    2315
        function txGasPrice(uint256 newGasPrice) external;
    2316
    2317
        /// Utility cheatcode to mark specific storage slot as warm, simulating a prior read.
    2318
        function warmSlot(address target, bytes32 slot) external;
    2319
    2320
        /// Sets `block.timestamp`.
    2321
        function warp(uint256 newTimestamp) external;
    2322
    2323
        /// `deleteSnapshot` is being deprecated in favor of `deleteStateSnapshot`. It will be removed in future versions.
    2324
        function deleteSnapshot(uint256 snapshotId) external returns (bool success);
    2325
    2326
        /// `deleteSnapshots` is being deprecated in favor of `deleteStateSnapshots`. It will be removed in future versions.
    2327
        function deleteSnapshots() external;
    2328
    2329
        /// `revertToAndDelete` is being deprecated in favor of `revertToStateAndDelete`. It will be removed in future versions.
    2330
        function revertToAndDelete(uint256 snapshotId) external returns (bool success);
    2331
    2332
        /// `revertTo` is being deprecated in favor of `revertToState`. It will be removed in future versions.
    2333
        function revertTo(uint256 snapshotId) external returns (bool success);
    2334
    2335
        /// `snapshot` is being deprecated in favor of `snapshotState`. It will be removed in future versions.
    2336
        function snapshot() external returns (uint256 snapshotId);
    2337
    2338
        // ======== Testing ========
    2339
    2340
        /// Expect a call to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2341
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;
    2342
    2343
        /// Expect given number of calls to an address with the specified `msg.value` and calldata, and a *minimum* amount of gas.
    2344
        function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)
    2345
            external;
    2346
    2347
        /// Expects a call to an address with the specified calldata.
    2348
        /// Calldata can either be a strict or a partial match.
    2349
        function expectCall(address callee, bytes calldata data) external;
    2350
    2351
        /// Expects given number of calls to an address with the specified calldata.
    2352
        function expectCall(address callee, bytes calldata data, uint64 count) external;
    2353
    2354
        /// Expects a call to an address with the specified `msg.value` and calldata.
    2355
        function expectCall(address callee, uint256 msgValue, bytes calldata data) external;
    2356
    2357
        /// Expects given number of calls to an address with the specified `msg.value` and calldata.
    2358
        function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;
    2359
    2360
        /// Expect a call to an address with the specified `msg.value`, gas, and calldata.
    2361
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;
    2362
    2363
        /// Expects given number of calls to an address with the specified `msg.value`, gas, and calldata.
    2364
        function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;
    2365
    2366
        /// Expects the deployment of the specified bytecode by the specified address using the CREATE opcode
    2367
        function expectCreate(bytes calldata bytecode, address deployer) external;
    2368
    2369
        /// Expects the deployment of the specified bytecode by the specified address using the CREATE2 opcode
    2370
        function expectCreate2(bytes calldata bytecode, address deployer) external;
    2371
    2372
        /// Prepare an expected anonymous log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2373
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2374
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2375
        function expectEmitAnonymous(bool checkTopic0, bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData)
    2376
            external;
    2377
    2378
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2379
        function expectEmitAnonymous(
    2380
            bool checkTopic0,
    2381
            bool checkTopic1,
    2382
            bool checkTopic2,
    2383
            bool checkTopic3,
    2384
            bool checkData,
    2385
            address emitter
    2386
        ) external;
    2387
    2388
        /// Prepare an expected anonymous log with all topic and data checks enabled.
    2389
        /// Call this function, then emit an anonymous event, then call a function. Internally after the call, we check if
    2390
        /// logs were emitted in the expected order with the expected topics and data.
    2391
        function expectEmitAnonymous() external;
    2392
    2393
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2394
        function expectEmitAnonymous(address emitter) external;
    2395
    2396
        /// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData.).
    2397
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2398
        /// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
    2399
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;
    2400
    2401
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2402
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) external;
    2403
    2404
        /// Prepare an expected log with all topic and data checks enabled.
    2405
        /// Call this function, then emit an event, then call a function. Internally after the call, we check if
    2406
        /// logs were emitted in the expected order with the expected topics and data.
    2407
        function expectEmit() external;
    2408
    2409
        /// Same as the previous method, but also checks supplied address against emitting contract.
    2410
        function expectEmit(address emitter) external;
    2411
    2412
        /// Expect a given number of logs with the provided topics.
    2413
        function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, uint64 count) external;
    2414
    2415
        /// Expect a given number of logs from a specific emitter with the provided topics.
    2416
        function expectEmit(
    2417
            bool checkTopic1,
    2418
            bool checkTopic2,
    2419
            bool checkTopic3,
    2420
            bool checkData,
    2421
            address emitter,
    2422
            uint64 count
    2423
        ) external;
    2424
    2425
        /// Expect a given number of logs with all topic and data checks enabled.
    2426
        function expectEmit(uint64 count) external;
    2427
    2428
        /// Expect a given number of logs from a specific emitter with all topic and data checks enabled.
    2429
        function expectEmit(address emitter, uint64 count) external;
    2430
    2431
        /// Expects an error on next call that starts with the revert data.
    2432
        function expectPartialRevert(bytes4 revertData) external;
    2433
    2434
        /// Expects an error on next call to reverter address, that starts with the revert data.
    2435
        function expectPartialRevert(bytes4 revertData, address reverter) external;
    2436
    2437
        /// Expects an error on next call with any revert data.
    2438
        function expectRevert() external;
    2439
    2440
        /// Expects an error on next call that exactly matches the revert data.
    2441
        function expectRevert(bytes4 revertData) external;
    2442
    2443
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that match the revert data.
    2444
        function expectRevert(bytes4 revertData, address reverter, uint64 count) external;
    2445
    2446
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address that exactly match the revert data.
    2447
        function expectRevert(bytes calldata revertData, address reverter, uint64 count) external;
    2448
    2449
        /// Expects an error on next call that exactly matches the revert data.
    2450
        function expectRevert(bytes calldata revertData) external;
    2451
    2452
        /// Expects an error with any revert data on next call to reverter address.
    2453
        function expectRevert(address reverter) external;
    2454
    2455
        /// Expects an error from reverter address on next call, with any revert data.
    2456
        function expectRevert(bytes4 revertData, address reverter) external;
    2457
    2458
        /// Expects an error from reverter address on next call, that exactly matches the revert data.
    2459
        function expectRevert(bytes calldata revertData, address reverter) external;
    2460
    2461
        /// Expects a `count` number of reverts from the upcoming calls with any revert data or reverter.
    2462
        function expectRevert(uint64 count) external;
    2463
    2464
        /// Expects a `count` number of reverts from the upcoming calls that match the revert data.
    2465
        function expectRevert(bytes4 revertData, uint64 count) external;
    2466
    2467
        /// Expects a `count` number of reverts from the upcoming calls that exactly match the revert data.
    2468
        function expectRevert(bytes calldata revertData, uint64 count) external;
    2469
    2470
        /// Expects a `count` number of reverts from the upcoming calls from the reverter address.
    2471
        function expectRevert(address reverter, uint64 count) external;
    2472
    2473
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other
    2474
        /// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.
    2475
        function expectSafeMemory(uint64 min, uint64 max) external;
    2476
    2477
        /// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.
    2478
        /// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges
    2479
        /// to the set.
    2480
        function expectSafeMemoryCall(uint64 min, uint64 max) external;
    2481
    2482
        /// Marks a test as skipped. Must be called at the top level of a test.
    2483
        function skip(bool skipTest) external;
    2484
    2485
        /// Marks a test as skipped with a reason. Must be called at the top level of a test.
    2486
        function skip(bool skipTest, string calldata reason) external;
    2487
    2488
        /// Stops all safe memory expectation in the current subcontext.
    2489
        function stopExpectSafeMemory() external;
    2490
    2491
        // ======== Utilities ========
    2492
    2493
        /// Causes the next contract creation (via new) to fail and return its initcode in the returndata buffer.
    2494
        /// This allows type-safe access to the initcode payload that would be used for contract creation.
    2495
        /// Example usage:
    2496
        /// vm.interceptInitcode();
    2497
        /// bytes memory initcode;
    2498
        /// try new MyContract(param1, param2) { assert(false); }
    2499
        /// catch (bytes memory interceptedInitcode) { initcode = interceptedInitcode; }
    2500
        function interceptInitcode() external;
    2501
    }
    2502
    0.0% lib/forge-std/src/console.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    4
    library console {
    5
        address constant CONSOLE_ADDRESS =
    6
            0x000000000000000000636F6e736F6c652e6c6f67;
    7
    8
        function _sendLogPayloadImplementation(bytes memory payload) internal view {
    9
            address consoleAddress = CONSOLE_ADDRESS;
    10
            /// @solidity memory-safe-assembly
    11
            assembly {
    12
                pop(
    13
                    staticcall(
    14
                        gas(),
    15
                        consoleAddress,
    16
                        add(payload, 32),
    17
                        mload(payload),
    18
                        0,
    19
                        0
    20
                    )
    21
                )
    22
            }
    23
        }
    24
    25
        function _castToPure(
    26
          function(bytes memory) internal view fnIn
    27
        ) internal pure returns (function(bytes memory) pure fnOut) {
    28
            assembly {
    29
                fnOut := fnIn
    30
            }
    31
        }
    32
    33
        function _sendLogPayload(bytes memory payload) internal pure {
    34
            _castToPure(_sendLogPayloadImplementation)(payload);
    35
        }
    36
    37
        function log() internal pure {
    38
            _sendLogPayload(abi.encodeWithSignature("log()"));
    39
        }
    40
    41
        function logInt(int256 p0) internal pure {
    42
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    43
        }
    44
    45
        function logUint(uint256 p0) internal pure {
    46
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    47
        }
    48
    49
        function logString(string memory p0) internal pure {
    50
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    51
        }
    52
    53
        function logBool(bool p0) internal pure {
    54
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    55
        }
    56
    57
        function logAddress(address p0) internal pure {
    58
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    59
        }
    60
    61
        function logBytes(bytes memory p0) internal pure {
    62
            _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    63
        }
    64
    65
        function logBytes1(bytes1 p0) internal pure {
    66
            _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    67
        }
    68
    69
        function logBytes2(bytes2 p0) internal pure {
    70
            _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    71
        }
    72
    73
        function logBytes3(bytes3 p0) internal pure {
    74
            _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    75
        }
    76
    77
        function logBytes4(bytes4 p0) internal pure {
    78
            _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    79
        }
    80
    81
        function logBytes5(bytes5 p0) internal pure {
    82
            _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    83
        }
    84
    85
        function logBytes6(bytes6 p0) internal pure {
    86
            _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    87
        }
    88
    89
        function logBytes7(bytes7 p0) internal pure {
    90
            _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    91
        }
    92
    93
        function logBytes8(bytes8 p0) internal pure {
    94
            _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    95
        }
    96
    97
        function logBytes9(bytes9 p0) internal pure {
    98
            _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    99
        }
    100
    101
        function logBytes10(bytes10 p0) internal pure {
    102
            _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    103
        }
    104
    105
        function logBytes11(bytes11 p0) internal pure {
    106
            _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    107
        }
    108
    109
        function logBytes12(bytes12 p0) internal pure {
    110
            _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    111
        }
    112
    113
        function logBytes13(bytes13 p0) internal pure {
    114
            _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    115
        }
    116
    117
        function logBytes14(bytes14 p0) internal pure {
    118
            _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    119
        }
    120
    121
        function logBytes15(bytes15 p0) internal pure {
    122
            _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    123
        }
    124
    125
        function logBytes16(bytes16 p0) internal pure {
    126
            _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    127
        }
    128
    129
        function logBytes17(bytes17 p0) internal pure {
    130
            _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    131
        }
    132
    133
        function logBytes18(bytes18 p0) internal pure {
    134
            _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    135
        }
    136
    137
        function logBytes19(bytes19 p0) internal pure {
    138
            _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    139
        }
    140
    141
        function logBytes20(bytes20 p0) internal pure {
    142
            _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    143
        }
    144
    145
        function logBytes21(bytes21 p0) internal pure {
    146
            _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    147
        }
    148
    149
        function logBytes22(bytes22 p0) internal pure {
    150
            _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    151
        }
    152
    153
        function logBytes23(bytes23 p0) internal pure {
    154
            _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    155
        }
    156
    157
        function logBytes24(bytes24 p0) internal pure {
    158
            _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    159
        }
    160
    161
        function logBytes25(bytes25 p0) internal pure {
    162
            _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    163
        }
    164
    165
        function logBytes26(bytes26 p0) internal pure {
    166
            _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    167
        }
    168
    169
        function logBytes27(bytes27 p0) internal pure {
    170
            _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    171
        }
    172
    173
        function logBytes28(bytes28 p0) internal pure {
    174
            _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    175
        }
    176
    177
        function logBytes29(bytes29 p0) internal pure {
    178
            _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    179
        }
    180
    181
        function logBytes30(bytes30 p0) internal pure {
    182
            _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    183
        }
    184
    185
        function logBytes31(bytes31 p0) internal pure {
    186
            _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    187
        }
    188
    189
        function logBytes32(bytes32 p0) internal pure {
    190
            _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    191
        }
    192
    193
        function log(uint256 p0) internal pure {
    194
            _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    195
        }
    196
    197
        function log(int256 p0) internal pure {
    198
            _sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
    199
        }
    200
    201
        function log(string memory p0) internal pure {
    202
            _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    203
        }
    204
    205
        function log(bool p0) internal pure {
    206
            _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    207
        }
    208
    209
        function log(address p0) internal pure {
    210
            _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    211
        }
    212
    213
        function log(uint256 p0, uint256 p1) internal pure {
    214
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
    215
        }
    216
    217
        function log(uint256 p0, string memory p1) internal pure {
    218
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
    219
        }
    220
    221
        function log(uint256 p0, bool p1) internal pure {
    222
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
    223
        }
    224
    225
        function log(uint256 p0, address p1) internal pure {
    226
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
    227
        }
    228
    229
        function log(string memory p0, uint256 p1) internal pure {
    230
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
    231
        }
    232
    233
        function log(string memory p0, int256 p1) internal pure {
    234
            _sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1));
    235
        }
    236
    237
        function log(string memory p0, string memory p1) internal pure {
    238
            _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    239
        }
    240
    241
        function log(string memory p0, bool p1) internal pure {
    242
            _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    243
        }
    244
    245
        function log(string memory p0, address p1) internal pure {
    246
            _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    247
        }
    248
    249
        function log(bool p0, uint256 p1) internal pure {
    250
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
    251
        }
    252
    253
        function log(bool p0, string memory p1) internal pure {
    254
            _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    255
        }
    256
    257
        function log(bool p0, bool p1) internal pure {
    258
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    259
        }
    260
    261
        function log(bool p0, address p1) internal pure {
    262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    263
        }
    264
    265
        function log(address p0, uint256 p1) internal pure {
    266
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
    267
        }
    268
    269
        function log(address p0, string memory p1) internal pure {
    270
            _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    271
        }
    272
    273
        function log(address p0, bool p1) internal pure {
    274
            _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    275
        }
    276
    277
        function log(address p0, address p1) internal pure {
    278
            _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    279
        }
    280
    281
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    282
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
    283
        }
    284
    285
        function log(uint256 p0, uint256 p1, string memory p2) internal pure {
    286
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
    287
        }
    288
    289
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    290
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
    291
        }
    292
    293
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    294
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
    295
        }
    296
    297
        function log(uint256 p0, string memory p1, uint256 p2) internal pure {
    298
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
    299
        }
    300
    301
        function log(uint256 p0, string memory p1, string memory p2) internal pure {
    302
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
    303
        }
    304
    305
        function log(uint256 p0, string memory p1, bool p2) internal pure {
    306
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
    307
        }
    308
    309
        function log(uint256 p0, string memory p1, address p2) internal pure {
    310
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
    311
        }
    312
    313
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    314
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
    315
        }
    316
    317
        function log(uint256 p0, bool p1, string memory p2) internal pure {
    318
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
    319
        }
    320
    321
        function log(uint256 p0, bool p1, bool p2) internal pure {
    322
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
    323
        }
    324
    325
        function log(uint256 p0, bool p1, address p2) internal pure {
    326
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
    327
        }
    328
    329
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    330
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
    331
        }
    332
    333
        function log(uint256 p0, address p1, string memory p2) internal pure {
    334
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
    335
        }
    336
    337
        function log(uint256 p0, address p1, bool p2) internal pure {
    338
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
    339
        }
    340
    341
        function log(uint256 p0, address p1, address p2) internal pure {
    342
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
    343
        }
    344
    345
        function log(string memory p0, uint256 p1, uint256 p2) internal pure {
    346
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
    347
        }
    348
    349
        function log(string memory p0, uint256 p1, string memory p2) internal pure {
    350
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
    351
        }
    352
    353
        function log(string memory p0, uint256 p1, bool p2) internal pure {
    354
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
    355
        }
    356
    357
        function log(string memory p0, uint256 p1, address p2) internal pure {
    358
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
    359
        }
    360
    361
        function log(string memory p0, string memory p1, uint256 p2) internal pure {
    362
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
    363
        }
    364
    365
        function log(string memory p0, string memory p1, string memory p2) internal pure {
    366
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    367
        }
    368
    369
        function log(string memory p0, string memory p1, bool p2) internal pure {
    370
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    371
        }
    372
    373
        function log(string memory p0, string memory p1, address p2) internal pure {
    374
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    375
        }
    376
    377
        function log(string memory p0, bool p1, uint256 p2) internal pure {
    378
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
    379
        }
    380
    381
        function log(string memory p0, bool p1, string memory p2) internal pure {
    382
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    383
        }
    384
    385
        function log(string memory p0, bool p1, bool p2) internal pure {
    386
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    387
        }
    388
    389
        function log(string memory p0, bool p1, address p2) internal pure {
    390
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    391
        }
    392
    393
        function log(string memory p0, address p1, uint256 p2) internal pure {
    394
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
    395
        }
    396
    397
        function log(string memory p0, address p1, string memory p2) internal pure {
    398
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    399
        }
    400
    401
        function log(string memory p0, address p1, bool p2) internal pure {
    402
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    403
        }
    404
    405
        function log(string memory p0, address p1, address p2) internal pure {
    406
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    407
        }
    408
    409
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    410
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
    411
        }
    412
    413
        function log(bool p0, uint256 p1, string memory p2) internal pure {
    414
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
    415
        }
    416
    417
        function log(bool p0, uint256 p1, bool p2) internal pure {
    418
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
    419
        }
    420
    421
        function log(bool p0, uint256 p1, address p2) internal pure {
    422
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
    423
        }
    424
    425
        function log(bool p0, string memory p1, uint256 p2) internal pure {
    426
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
    427
        }
    428
    429
        function log(bool p0, string memory p1, string memory p2) internal pure {
    430
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    431
        }
    432
    433
        function log(bool p0, string memory p1, bool p2) internal pure {
    434
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    435
        }
    436
    437
        function log(bool p0, string memory p1, address p2) internal pure {
    438
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    439
        }
    440
    441
        function log(bool p0, bool p1, uint256 p2) internal pure {
    442
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
    443
        }
    444
    445
        function log(bool p0, bool p1, string memory p2) internal pure {
    446
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    447
        }
    448
    449
        function log(bool p0, bool p1, bool p2) internal pure {
    450
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    451
        }
    452
    453
        function log(bool p0, bool p1, address p2) internal pure {
    454
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    455
        }
    456
    457
        function log(bool p0, address p1, uint256 p2) internal pure {
    458
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
    459
        }
    460
    461
        function log(bool p0, address p1, string memory p2) internal pure {
    462
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    463
        }
    464
    465
        function log(bool p0, address p1, bool p2) internal pure {
    466
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    467
        }
    468
    469
        function log(bool p0, address p1, address p2) internal pure {
    470
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    471
        }
    472
    473
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    474
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
    475
        }
    476
    477
        function log(address p0, uint256 p1, string memory p2) internal pure {
    478
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
    479
        }
    480
    481
        function log(address p0, uint256 p1, bool p2) internal pure {
    482
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
    483
        }
    484
    485
        function log(address p0, uint256 p1, address p2) internal pure {
    486
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
    487
        }
    488
    489
        function log(address p0, string memory p1, uint256 p2) internal pure {
    490
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
    491
        }
    492
    493
        function log(address p0, string memory p1, string memory p2) internal pure {
    494
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    495
        }
    496
    497
        function log(address p0, string memory p1, bool p2) internal pure {
    498
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    499
        }
    500
    501
        function log(address p0, string memory p1, address p2) internal pure {
    502
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    503
        }
    504
    505
        function log(address p0, bool p1, uint256 p2) internal pure {
    506
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
    507
        }
    508
    509
        function log(address p0, bool p1, string memory p2) internal pure {
    510
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    511
        }
    512
    513
        function log(address p0, bool p1, bool p2) internal pure {
    514
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    515
        }
    516
    517
        function log(address p0, bool p1, address p2) internal pure {
    518
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    519
        }
    520
    521
        function log(address p0, address p1, uint256 p2) internal pure {
    522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
    523
        }
    524
    525
        function log(address p0, address p1, string memory p2) internal pure {
    526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    527
        }
    528
    529
        function log(address p0, address p1, bool p2) internal pure {
    530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    531
        }
    532
    533
        function log(address p0, address p1, address p2) internal pure {
    534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    535
        }
    536
    537
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    538
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
    539
        }
    540
    541
        function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    542
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
    543
        }
    544
    545
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    546
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
    547
        }
    548
    549
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    550
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
    551
        }
    552
    553
        function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    554
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
    555
        }
    556
    557
        function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
    558
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
    559
        }
    560
    561
        function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
    562
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
    563
        }
    564
    565
        function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
    566
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
    567
        }
    568
    569
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    570
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
    571
        }
    572
    573
        function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
    574
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
    575
        }
    576
    577
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    578
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
    579
        }
    580
    581
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    582
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
    583
        }
    584
    585
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    586
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
    587
        }
    588
    589
        function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
    590
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
    591
        }
    592
    593
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    594
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
    595
        }
    596
    597
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    598
            _sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
    599
        }
    600
    601
        function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    602
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
    603
        }
    604
    605
        function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
    606
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
    607
        }
    608
    609
        function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
    610
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
    611
        }
    612
    613
        function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
    614
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
    615
        }
    616
    617
        function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
    618
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
    619
        }
    620
    621
        function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
    622
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
    623
        }
    624
    625
        function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
    626
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
    627
        }
    628
    629
        function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
    630
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
    631
        }
    632
    633
        function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
    634
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
    635
        }
    636
    637
        function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
    638
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
    639
        }
    640
    641
        function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
    642
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
    643
        }
    644
    645
        function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
    646
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
    647
        }
    648
    649
        function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
    650
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
    651
        }
    652
    653
        function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
    654
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
    655
        }
    656
    657
        function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
    658
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
    659
        }
    660
    661
        function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
    662
            _sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
    663
        }
    664
    665
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    666
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
    667
        }
    668
    669
        function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
    670
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
    671
        }
    672
    673
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    674
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
    675
        }
    676
    677
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    678
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
    679
        }
    680
    681
        function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
    682
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
    683
        }
    684
    685
        function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
    686
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
    687
        }
    688
    689
        function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
    690
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
    691
        }
    692
    693
        function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
    694
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
    695
        }
    696
    697
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    698
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
    699
        }
    700
    701
        function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
    702
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
    703
        }
    704
    705
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    706
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
    707
        }
    708
    709
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    710
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
    711
        }
    712
    713
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    714
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
    715
        }
    716
    717
        function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
    718
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
    719
        }
    720
    721
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    722
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
    723
        }
    724
    725
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    726
            _sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
    727
        }
    728
    729
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    730
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
    731
        }
    732
    733
        function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
    734
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
    735
        }
    736
    737
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    738
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
    739
        }
    740
    741
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    742
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
    743
        }
    744
    745
        function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
    746
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
    747
        }
    748
    749
        function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
    750
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
    751
        }
    752
    753
        function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
    754
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
    755
        }
    756
    757
        function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
    758
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
    759
        }
    760
    761
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    762
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
    763
        }
    764
    765
        function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
    766
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
    767
        }
    768
    769
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    770
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
    771
        }
    772
    773
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    774
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
    775
        }
    776
    777
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    778
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
    779
        }
    780
    781
        function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
    782
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
    783
        }
    784
    785
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    786
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
    787
        }
    788
    789
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    790
            _sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
    791
        }
    792
    793
        function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    794
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
    795
        }
    796
    797
        function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    798
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
    799
        }
    800
    801
        function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
    802
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
    803
        }
    804
    805
        function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
    806
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
    807
        }
    808
    809
        function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    810
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
    811
        }
    812
    813
        function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
    814
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
    815
        }
    816
    817
        function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
    818
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
    819
        }
    820
    821
        function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
    822
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
    823
        }
    824
    825
        function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
    826
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
    827
        }
    828
    829
        function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
    830
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
    831
        }
    832
    833
        function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
    834
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
    835
        }
    836
    837
        function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
    838
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
    839
        }
    840
    841
        function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
    842
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
    843
        }
    844
    845
        function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
    846
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
    847
        }
    848
    849
        function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
    850
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
    851
        }
    852
    853
        function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
    854
            _sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
    855
        }
    856
    857
        function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    858
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
    859
        }
    860
    861
        function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
    862
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
    863
        }
    864
    865
        function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
    866
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
    867
        }
    868
    869
        function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
    870
            _sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
    871
        }
    872
    873
        function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
    874
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
    875
        }
    876
    877
        function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
    878
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    879
        }
    880
    881
        function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
    882
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    883
        }
    884
    885
        function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
    886
            _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    887
        }
    888
    889
        function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
    890
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
    891
        }
    892
    893
        function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
    894
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    895
        }
    896
    897
        function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
    898
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    899
        }
    900
    901
        function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
    902
            _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    903
        }
    904
    905
        function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
    906
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
    907
        }
    908
    909
        function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
    910
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    911
        }
    912
    913
        function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
    914
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    915
        }
    916
    917
        function log(string memory p0, string memory p1, address p2, address p3) internal pure {
    918
            _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    919
        }
    920
    921
        function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
    922
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
    923
        }
    924
    925
        function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
    926
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
    927
        }
    928
    929
        function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
    930
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
    931
        }
    932
    933
        function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
    934
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
    935
        }
    936
    937
        function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
    938
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
    939
        }
    940
    941
        function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
    942
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    943
        }
    944
    945
        function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
    946
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    947
        }
    948
    949
        function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
    950
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    951
        }
    952
    953
        function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
    954
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
    955
        }
    956
    957
        function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
    958
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    959
        }
    960
    961
        function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
    962
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    963
        }
    964
    965
        function log(string memory p0, bool p1, bool p2, address p3) internal pure {
    966
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    967
        }
    968
    969
        function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
    970
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
    971
        }
    972
    973
        function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
    974
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    975
        }
    976
    977
        function log(string memory p0, bool p1, address p2, bool p3) internal pure {
    978
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    979
        }
    980
    981
        function log(string memory p0, bool p1, address p2, address p3) internal pure {
    982
            _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    983
        }
    984
    985
        function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
    986
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
    987
        }
    988
    989
        function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
    990
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
    991
        }
    992
    993
        function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
    994
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
    995
        }
    996
    997
        function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
    998
            _sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
    999
        }
    1000
    1001
        function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
    1002
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
    1003
        }
    1004
    1005
        function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
    1006
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    1007
        }
    1008
    1009
        function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
    1010
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    1011
        }
    1012
    1013
        function log(string memory p0, address p1, string memory p2, address p3) internal pure {
    1014
            _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    1015
        }
    1016
    1017
        function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
    1018
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
    1019
        }
    1020
    1021
        function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
    1022
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    1023
        }
    1024
    1025
        function log(string memory p0, address p1, bool p2, bool p3) internal pure {
    1026
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    1027
        }
    1028
    1029
        function log(string memory p0, address p1, bool p2, address p3) internal pure {
    1030
            _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    1031
        }
    1032
    1033
        function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
    1034
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
    1035
        }
    1036
    1037
        function log(string memory p0, address p1, address p2, string memory p3) internal pure {
    1038
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    1039
        }
    1040
    1041
        function log(string memory p0, address p1, address p2, bool p3) internal pure {
    1042
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    1043
        }
    1044
    1045
        function log(string memory p0, address p1, address p2, address p3) internal pure {
    1046
            _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    1047
        }
    1048
    1049
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1050
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
    1051
        }
    1052
    1053
        function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1054
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
    1055
        }
    1056
    1057
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1058
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
    1059
        }
    1060
    1061
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    1062
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
    1063
        }
    1064
    1065
        function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1066
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
    1067
        }
    1068
    1069
        function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1070
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
    1071
        }
    1072
    1073
        function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
    1074
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
    1075
        }
    1076
    1077
        function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
    1078
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
    1079
        }
    1080
    1081
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1082
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
    1083
        }
    1084
    1085
        function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
    1086
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
    1087
        }
    1088
    1089
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    1090
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
    1091
        }
    1092
    1093
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    1094
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
    1095
        }
    1096
    1097
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    1098
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
    1099
        }
    1100
    1101
        function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
    1102
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
    1103
        }
    1104
    1105
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    1106
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
    1107
        }
    1108
    1109
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    1110
            _sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
    1111
        }
    1112
    1113
        function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1114
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
    1115
        }
    1116
    1117
        function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1118
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
    1119
        }
    1120
    1121
        function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
    1122
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
    1123
        }
    1124
    1125
        function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
    1126
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
    1127
        }
    1128
    1129
        function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1130
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
    1131
        }
    1132
    1133
        function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
    1134
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    1135
        }
    1136
    1137
        function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
    1138
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    1139
        }
    1140
    1141
        function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
    1142
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    1143
        }
    1144
    1145
        function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
    1146
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
    1147
        }
    1148
    1149
        function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
    1150
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    1151
        }
    1152
    1153
        function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
    1154
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    1155
        }
    1156
    1157
        function log(bool p0, string memory p1, bool p2, address p3) internal pure {
    1158
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    1159
        }
    1160
    1161
        function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
    1162
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
    1163
        }
    1164
    1165
        function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
    1166
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    1167
        }
    1168
    1169
        function log(bool p0, string memory p1, address p2, bool p3) internal pure {
    1170
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    1171
        }
    1172
    1173
        function log(bool p0, string memory p1, address p2, address p3) internal pure {
    1174
            _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    1175
        }
    1176
    1177
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1178
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
    1179
        }
    1180
    1181
        function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
    1182
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
    1183
        }
    1184
    1185
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    1186
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
    1187
        }
    1188
    1189
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    1190
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
    1191
        }
    1192
    1193
        function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
    1194
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
    1195
        }
    1196
    1197
        function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
    1198
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    1199
        }
    1200
    1201
        function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
    1202
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    1203
        }
    1204
    1205
        function log(bool p0, bool p1, string memory p2, address p3) internal pure {
    1206
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    1207
        }
    1208
    1209
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    1210
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
    1211
        }
    1212
    1213
        function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
    1214
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    1215
        }
    1216
    1217
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    1218
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    1219
        }
    1220
    1221
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    1222
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    1223
        }
    1224
    1225
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    1226
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
    1227
        }
    1228
    1229
        function log(bool p0, bool p1, address p2, string memory p3) internal pure {
    1230
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    1231
        }
    1232
    1233
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    1234
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    1235
        }
    1236
    1237
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    1238
            _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    1239
        }
    1240
    1241
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    1242
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
    1243
        }
    1244
    1245
        function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
    1246
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
    1247
        }
    1248
    1249
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    1250
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
    1251
        }
    1252
    1253
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    1254
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
    1255
        }
    1256
    1257
        function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
    1258
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
    1259
        }
    1260
    1261
        function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
    1262
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    1263
        }
    1264
    1265
        function log(bool p0, address p1, string memory p2, bool p3) internal pure {
    1266
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    1267
        }
    1268
    1269
        function log(bool p0, address p1, string memory p2, address p3) internal pure {
    1270
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    1271
        }
    1272
    1273
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    1274
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
    1275
        }
    1276
    1277
        function log(bool p0, address p1, bool p2, string memory p3) internal pure {
    1278
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    1279
        }
    1280
    1281
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    1282
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    1283
        }
    1284
    1285
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    1286
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    1287
        }
    1288
    1289
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    1290
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
    1291
        }
    1292
    1293
        function log(bool p0, address p1, address p2, string memory p3) internal pure {
    1294
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    1295
        }
    1296
    1297
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    1298
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    1299
        }
    1300
    1301
        function log(bool p0, address p1, address p2, address p3) internal pure {
    1302
            _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    1303
        }
    1304
    1305
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    1306
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
    1307
        }
    1308
    1309
        function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
    1310
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
    1311
        }
    1312
    1313
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    1314
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
    1315
        }
    1316
    1317
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    1318
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
    1319
        }
    1320
    1321
        function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
    1322
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
    1323
        }
    1324
    1325
        function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
    1326
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
    1327
        }
    1328
    1329
        function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
    1330
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
    1331
        }
    1332
    1333
        function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
    1334
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
    1335
        }
    1336
    1337
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    1338
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
    1339
        }
    1340
    1341
        function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
    1342
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
    1343
        }
    1344
    1345
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    1346
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
    1347
        }
    1348
    1349
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    1350
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
    1351
        }
    1352
    1353
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    1354
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
    1355
        }
    1356
    1357
        function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
    1358
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
    1359
        }
    1360
    1361
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    1362
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
    1363
        }
    1364
    1365
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    1366
            _sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
    1367
        }
    1368
    1369
        function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
    1370
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
    1371
        }
    1372
    1373
        function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
    1374
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
    1375
        }
    1376
    1377
        function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
    1378
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
    1379
        }
    1380
    1381
        function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
    1382
            _sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
    1383
        }
    1384
    1385
        function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
    1386
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
    1387
        }
    1388
    1389
        function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
    1390
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    1391
        }
    1392
    1393
        function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
    1394
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    1395
        }
    1396
    1397
        function log(address p0, string memory p1, string memory p2, address p3) internal pure {
    1398
            _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    1399
        }
    1400
    1401
        function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
    1402
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
    1403
        }
    1404
    1405
        function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
    1406
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    1407
        }
    1408
    1409
        function log(address p0, string memory p1, bool p2, bool p3) internal pure {
    1410
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    1411
        }
    1412
    1413
        function log(address p0, string memory p1, bool p2, address p3) internal pure {
    1414
            _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    1415
        }
    1416
    1417
        function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
    1418
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
    1419
        }
    1420
    1421
        function log(address p0, string memory p1, address p2, string memory p3) internal pure {
    1422
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    1423
        }
    1424
    1425
        function log(address p0, string memory p1, address p2, bool p3) internal pure {
    1426
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    1427
        }
    1428
    1429
        function log(address p0, string memory p1, address p2, address p3) internal pure {
    1430
            _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    1431
        }
    1432
    1433
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    1434
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
    1435
        }
    1436
    1437
        function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
    1438
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
    1439
        }
    1440
    1441
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    1442
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
    1443
        }
    1444
    1445
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    1446
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
    1447
        }
    1448
    1449
        function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
    1450
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
    1451
        }
    1452
    1453
        function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
    1454
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    1455
        }
    1456
    1457
        function log(address p0, bool p1, string memory p2, bool p3) internal pure {
    1458
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    1459
        }
    1460
    1461
        function log(address p0, bool p1, string memory p2, address p3) internal pure {
    1462
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    1463
        }
    1464
    1465
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    1466
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
    1467
        }
    1468
    1469
        function log(address p0, bool p1, bool p2, string memory p3) internal pure {
    1470
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    1471
        }
    1472
    1473
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    1474
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    1475
        }
    1476
    1477
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    1478
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    1479
        }
    1480
    1481
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    1482
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
    1483
        }
    1484
    1485
        function log(address p0, bool p1, address p2, string memory p3) internal pure {
    1486
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    1487
        }
    1488
    1489
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    1490
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    1491
        }
    1492
    1493
        function log(address p0, bool p1, address p2, address p3) internal pure {
    1494
            _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    1495
        }
    1496
    1497
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    1498
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
    1499
        }
    1500
    1501
        function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
    1502
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
    1503
        }
    1504
    1505
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    1506
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
    1507
        }
    1508
    1509
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    1510
            _sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
    1511
        }
    1512
    1513
        function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
    1514
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
    1515
        }
    1516
    1517
        function log(address p0, address p1, string memory p2, string memory p3) internal pure {
    1518
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    1519
        }
    1520
    1521
        function log(address p0, address p1, string memory p2, bool p3) internal pure {
    1522
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    1523
        }
    1524
    1525
        function log(address p0, address p1, string memory p2, address p3) internal pure {
    1526
            _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    1527
        }
    1528
    1529
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    1530
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
    1531
        }
    1532
    1533
        function log(address p0, address p1, bool p2, string memory p3) internal pure {
    1534
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    1535
        }
    1536
    1537
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    1538
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    1539
        }
    1540
    1541
        function log(address p0, address p1, bool p2, address p3) internal pure {
    1542
            _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    1543
        }
    1544
    1545
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    1546
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
    1547
        }
    1548
    1549
        function log(address p0, address p1, address p2, string memory p3) internal pure {
    1550
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    1551
        }
    1552
    1553
        function log(address p0, address p1, address p2, bool p3) internal pure {
    1554
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    1555
        }
    1556
    1557
        function log(address p0, address p1, address p2, address p3) internal pure {
    1558
            _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    1559
        }
    1560
    }
    1561
    0.0% lib/forge-std/src/console2.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.4.22 <0.9.0;
    3
    4
    import {console as console2} from "./console.sol";
    5
    0.0% lib/forge-std/src/interfaces/IMulticall3.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    pragma experimental ABIEncoderV2;
    5
    6
    interface IMulticall3 {
    7
        struct Call {
    8
            address target;
    9
            bytes callData;
    10
        }
    11
    12
        struct Call3 {
    13
            address target;
    14
            bool allowFailure;
    15
            bytes callData;
    16
        }
    17
    18
        struct Call3Value {
    19
            address target;
    20
            bool allowFailure;
    21
            uint256 value;
    22
            bytes callData;
    23
        }
    24
    25
        struct Result {
    26
            bool success;
    27
            bytes returnData;
    28
        }
    29
    30
        function aggregate(Call[] calldata calls) external payable returns (uint256 blockNumber, bytes[] memory returnData);
    31
    32
        function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
    33
    34
        function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
    35
    36
        function blockAndAggregate(Call[] calldata calls)
    37
            external
    38
            payable
    39
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    40
    41
        function getBasefee() external view returns (uint256 basefee);
    42
    43
        function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
    44
    45
        function getBlockNumber() external view returns (uint256 blockNumber);
    46
    47
        function getChainId() external view returns (uint256 chainid);
    48
    49
        function getCurrentBlockCoinbase() external view returns (address coinbase);
    50
    51
        function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
    52
    53
        function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
    54
    55
        function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
    56
    57
        function getEthBalance(address addr) external view returns (uint256 balance);
    58
    59
        function getLastBlockHash() external view returns (bytes32 blockHash);
    60
    61
        function tryAggregate(bool requireSuccess, Call[] calldata calls)
    62
            external
    63
            payable
    64
            returns (Result[] memory returnData);
    65
    66
        function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
    67
            external
    68
            payable
    69
            returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
    70
    }
    71
    0.0% lib/forge-std/src/safeconsole.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity >=0.6.2 <0.9.0;
    3
    4
    /// @author philogy <https://github.com/philogy>
    5
    /// @dev Code generated automatically by script.
    6
    library safeconsole {
    7
        uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;
    8
    9
        // Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)
    10
        // for the view-to-pure log trick.
    11
        function _sendLogPayload(uint256 offset, uint256 size) private pure {
    12
            function(uint256, uint256) internal view fnIn = _sendLogPayloadView;
    13
            function(uint256, uint256) internal pure pureSendLogPayload;
    14
            /// @solidity memory-safe-assembly
    15
            assembly {
    16
                pureSendLogPayload := fnIn
    17
            }
    18
            pureSendLogPayload(offset, size);
    19
        }
    20
    21
        function _sendLogPayloadView(uint256 offset, uint256 size) private view {
    22
            /// @solidity memory-safe-assembly
    23
            assembly {
    24
                pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))
    25
            }
    26
        }
    27
    28
        function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {
    29
            function(uint256, uint256, uint256) internal view fnIn = _memcopyView;
    30
            function(uint256, uint256, uint256) internal pure pureMemcopy;
    31
            /// @solidity memory-safe-assembly
    32
            assembly {
    33
                pureMemcopy := fnIn
    34
            }
    35
            pureMemcopy(fromOffset, toOffset, length);
    36
        }
    37
    38
        function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {
    39
            /// @solidity memory-safe-assembly
    40
            assembly {
    41
                pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))
    42
            }
    43
        }
    44
    45
        function logMemory(uint256 offset, uint256 length) internal pure {
    46
            if (offset >= 0x60) {
    47
                // Sufficient memory before slice to prepare call header.
    48
                bytes32 m0;
    49
                bytes32 m1;
    50
                bytes32 m2;
    51
                /// @solidity memory-safe-assembly
    52
                assembly {
    53
                    m0 := mload(sub(offset, 0x60))
    54
                    m1 := mload(sub(offset, 0x40))
    55
                    m2 := mload(sub(offset, 0x20))
    56
                    // Selector of `log(bytes)`.
    57
                    mstore(sub(offset, 0x60), 0x0be77f56)
    58
                    mstore(sub(offset, 0x40), 0x20)
    59
                    mstore(sub(offset, 0x20), length)
    60
                }
    61
                _sendLogPayload(offset - 0x44, length + 0x44);
    62
                /// @solidity memory-safe-assembly
    63
                assembly {
    64
                    mstore(sub(offset, 0x60), m0)
    65
                    mstore(sub(offset, 0x40), m1)
    66
                    mstore(sub(offset, 0x20), m2)
    67
                }
    68
            } else {
    69
                // Insufficient space, so copy slice forward, add header and reverse.
    70
                bytes32 m0;
    71
                bytes32 m1;
    72
                bytes32 m2;
    73
                uint256 endOffset = offset + length;
    74
                /// @solidity memory-safe-assembly
    75
                assembly {
    76
                    m0 := mload(add(endOffset, 0x00))
    77
                    m1 := mload(add(endOffset, 0x20))
    78
                    m2 := mload(add(endOffset, 0x40))
    79
                }
    80
                _memcopy(offset, offset + 0x60, length);
    81
                /// @solidity memory-safe-assembly
    82
                assembly {
    83
                    // Selector of `log(bytes)`.
    84
                    mstore(add(offset, 0x00), 0x0be77f56)
    85
                    mstore(add(offset, 0x20), 0x20)
    86
                    mstore(add(offset, 0x40), length)
    87
                }
    88
                _sendLogPayload(offset + 0x1c, length + 0x44);
    89
                _memcopy(offset + 0x60, offset, length);
    90
                /// @solidity memory-safe-assembly
    91
                assembly {
    92
                    mstore(add(endOffset, 0x00), m0)
    93
                    mstore(add(endOffset, 0x20), m1)
    94
                    mstore(add(endOffset, 0x40), m2)
    95
                }
    96
            }
    97
        }
    98
    99
        function log(address p0) internal pure {
    100
            bytes32 m0;
    101
            bytes32 m1;
    102
            /// @solidity memory-safe-assembly
    103
            assembly {
    104
                m0 := mload(0x00)
    105
                m1 := mload(0x20)
    106
                // Selector of `log(address)`.
    107
                mstore(0x00, 0x2c2ecbc2)
    108
                mstore(0x20, p0)
    109
            }
    110
            _sendLogPayload(0x1c, 0x24);
    111
            /// @solidity memory-safe-assembly
    112
            assembly {
    113
                mstore(0x00, m0)
    114
                mstore(0x20, m1)
    115
            }
    116
        }
    117
    118
        function log(bool p0) internal pure {
    119
            bytes32 m0;
    120
            bytes32 m1;
    121
            /// @solidity memory-safe-assembly
    122
            assembly {
    123
                m0 := mload(0x00)
    124
                m1 := mload(0x20)
    125
                // Selector of `log(bool)`.
    126
                mstore(0x00, 0x32458eed)
    127
                mstore(0x20, p0)
    128
            }
    129
            _sendLogPayload(0x1c, 0x24);
    130
            /// @solidity memory-safe-assembly
    131
            assembly {
    132
                mstore(0x00, m0)
    133
                mstore(0x20, m1)
    134
            }
    135
        }
    136
    137
        function log(uint256 p0) internal pure {
    138
            bytes32 m0;
    139
            bytes32 m1;
    140
            /// @solidity memory-safe-assembly
    141
            assembly {
    142
                m0 := mload(0x00)
    143
                m1 := mload(0x20)
    144
                // Selector of `log(uint256)`.
    145
                mstore(0x00, 0xf82c50f1)
    146
                mstore(0x20, p0)
    147
            }
    148
            _sendLogPayload(0x1c, 0x24);
    149
            /// @solidity memory-safe-assembly
    150
            assembly {
    151
                mstore(0x00, m0)
    152
                mstore(0x20, m1)
    153
            }
    154
        }
    155
    156
        function log(bytes32 p0) internal pure {
    157
            bytes32 m0;
    158
            bytes32 m1;
    159
            bytes32 m2;
    160
            bytes32 m3;
    161
            /// @solidity memory-safe-assembly
    162
            assembly {
    163
                function writeString(pos, w) {
    164
                    let length := 0
    165
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    166
                    mstore(pos, length)
    167
                    let shift := sub(256, shl(3, length))
    168
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    169
                }
    170
                m0 := mload(0x00)
    171
                m1 := mload(0x20)
    172
                m2 := mload(0x40)
    173
                m3 := mload(0x60)
    174
                // Selector of `log(string)`.
    175
                mstore(0x00, 0x41304fac)
    176
                mstore(0x20, 0x20)
    177
                writeString(0x40, p0)
    178
            }
    179
            _sendLogPayload(0x1c, 0x64);
    180
            /// @solidity memory-safe-assembly
    181
            assembly {
    182
                mstore(0x00, m0)
    183
                mstore(0x20, m1)
    184
                mstore(0x40, m2)
    185
                mstore(0x60, m3)
    186
            }
    187
        }
    188
    189
        function log(address p0, address p1) internal pure {
    190
            bytes32 m0;
    191
            bytes32 m1;
    192
            bytes32 m2;
    193
            /// @solidity memory-safe-assembly
    194
            assembly {
    195
                m0 := mload(0x00)
    196
                m1 := mload(0x20)
    197
                m2 := mload(0x40)
    198
                // Selector of `log(address,address)`.
    199
                mstore(0x00, 0xdaf0d4aa)
    200
                mstore(0x20, p0)
    201
                mstore(0x40, p1)
    202
            }
    203
            _sendLogPayload(0x1c, 0x44);
    204
            /// @solidity memory-safe-assembly
    205
            assembly {
    206
                mstore(0x00, m0)
    207
                mstore(0x20, m1)
    208
                mstore(0x40, m2)
    209
            }
    210
        }
    211
    212
        function log(address p0, bool p1) internal pure {
    213
            bytes32 m0;
    214
            bytes32 m1;
    215
            bytes32 m2;
    216
            /// @solidity memory-safe-assembly
    217
            assembly {
    218
                m0 := mload(0x00)
    219
                m1 := mload(0x20)
    220
                m2 := mload(0x40)
    221
                // Selector of `log(address,bool)`.
    222
                mstore(0x00, 0x75b605d3)
    223
                mstore(0x20, p0)
    224
                mstore(0x40, p1)
    225
            }
    226
            _sendLogPayload(0x1c, 0x44);
    227
            /// @solidity memory-safe-assembly
    228
            assembly {
    229
                mstore(0x00, m0)
    230
                mstore(0x20, m1)
    231
                mstore(0x40, m2)
    232
            }
    233
        }
    234
    235
        function log(address p0, uint256 p1) internal pure {
    236
            bytes32 m0;
    237
            bytes32 m1;
    238
            bytes32 m2;
    239
            /// @solidity memory-safe-assembly
    240
            assembly {
    241
                m0 := mload(0x00)
    242
                m1 := mload(0x20)
    243
                m2 := mload(0x40)
    244
                // Selector of `log(address,uint256)`.
    245
                mstore(0x00, 0x8309e8a8)
    246
                mstore(0x20, p0)
    247
                mstore(0x40, p1)
    248
            }
    249
            _sendLogPayload(0x1c, 0x44);
    250
            /// @solidity memory-safe-assembly
    251
            assembly {
    252
                mstore(0x00, m0)
    253
                mstore(0x20, m1)
    254
                mstore(0x40, m2)
    255
            }
    256
        }
    257
    258
        function log(address p0, bytes32 p1) internal pure {
    259
            bytes32 m0;
    260
            bytes32 m1;
    261
            bytes32 m2;
    262
            bytes32 m3;
    263
            bytes32 m4;
    264
            /// @solidity memory-safe-assembly
    265
            assembly {
    266
                function writeString(pos, w) {
    267
                    let length := 0
    268
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    269
                    mstore(pos, length)
    270
                    let shift := sub(256, shl(3, length))
    271
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    272
                }
    273
                m0 := mload(0x00)
    274
                m1 := mload(0x20)
    275
                m2 := mload(0x40)
    276
                m3 := mload(0x60)
    277
                m4 := mload(0x80)
    278
                // Selector of `log(address,string)`.
    279
                mstore(0x00, 0x759f86bb)
    280
                mstore(0x20, p0)
    281
                mstore(0x40, 0x40)
    282
                writeString(0x60, p1)
    283
            }
    284
            _sendLogPayload(0x1c, 0x84);
    285
            /// @solidity memory-safe-assembly
    286
            assembly {
    287
                mstore(0x00, m0)
    288
                mstore(0x20, m1)
    289
                mstore(0x40, m2)
    290
                mstore(0x60, m3)
    291
                mstore(0x80, m4)
    292
            }
    293
        }
    294
    295
        function log(bool p0, address p1) internal pure {
    296
            bytes32 m0;
    297
            bytes32 m1;
    298
            bytes32 m2;
    299
            /// @solidity memory-safe-assembly
    300
            assembly {
    301
                m0 := mload(0x00)
    302
                m1 := mload(0x20)
    303
                m2 := mload(0x40)
    304
                // Selector of `log(bool,address)`.
    305
                mstore(0x00, 0x853c4849)
    306
                mstore(0x20, p0)
    307
                mstore(0x40, p1)
    308
            }
    309
            _sendLogPayload(0x1c, 0x44);
    310
            /// @solidity memory-safe-assembly
    311
            assembly {
    312
                mstore(0x00, m0)
    313
                mstore(0x20, m1)
    314
                mstore(0x40, m2)
    315
            }
    316
        }
    317
    318
        function log(bool p0, bool p1) internal pure {
    319
            bytes32 m0;
    320
            bytes32 m1;
    321
            bytes32 m2;
    322
            /// @solidity memory-safe-assembly
    323
            assembly {
    324
                m0 := mload(0x00)
    325
                m1 := mload(0x20)
    326
                m2 := mload(0x40)
    327
                // Selector of `log(bool,bool)`.
    328
                mstore(0x00, 0x2a110e83)
    329
                mstore(0x20, p0)
    330
                mstore(0x40, p1)
    331
            }
    332
            _sendLogPayload(0x1c, 0x44);
    333
            /// @solidity memory-safe-assembly
    334
            assembly {
    335
                mstore(0x00, m0)
    336
                mstore(0x20, m1)
    337
                mstore(0x40, m2)
    338
            }
    339
        }
    340
    341
        function log(bool p0, uint256 p1) internal pure {
    342
            bytes32 m0;
    343
            bytes32 m1;
    344
            bytes32 m2;
    345
            /// @solidity memory-safe-assembly
    346
            assembly {
    347
                m0 := mload(0x00)
    348
                m1 := mload(0x20)
    349
                m2 := mload(0x40)
    350
                // Selector of `log(bool,uint256)`.
    351
                mstore(0x00, 0x399174d3)
    352
                mstore(0x20, p0)
    353
                mstore(0x40, p1)
    354
            }
    355
            _sendLogPayload(0x1c, 0x44);
    356
            /// @solidity memory-safe-assembly
    357
            assembly {
    358
                mstore(0x00, m0)
    359
                mstore(0x20, m1)
    360
                mstore(0x40, m2)
    361
            }
    362
        }
    363
    364
        function log(bool p0, bytes32 p1) internal pure {
    365
            bytes32 m0;
    366
            bytes32 m1;
    367
            bytes32 m2;
    368
            bytes32 m3;
    369
            bytes32 m4;
    370
            /// @solidity memory-safe-assembly
    371
            assembly {
    372
                function writeString(pos, w) {
    373
                    let length := 0
    374
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    375
                    mstore(pos, length)
    376
                    let shift := sub(256, shl(3, length))
    377
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    378
                }
    379
                m0 := mload(0x00)
    380
                m1 := mload(0x20)
    381
                m2 := mload(0x40)
    382
                m3 := mload(0x60)
    383
                m4 := mload(0x80)
    384
                // Selector of `log(bool,string)`.
    385
                mstore(0x00, 0x8feac525)
    386
                mstore(0x20, p0)
    387
                mstore(0x40, 0x40)
    388
                writeString(0x60, p1)
    389
            }
    390
            _sendLogPayload(0x1c, 0x84);
    391
            /// @solidity memory-safe-assembly
    392
            assembly {
    393
                mstore(0x00, m0)
    394
                mstore(0x20, m1)
    395
                mstore(0x40, m2)
    396
                mstore(0x60, m3)
    397
                mstore(0x80, m4)
    398
            }
    399
        }
    400
    401
        function log(uint256 p0, address p1) internal pure {
    402
            bytes32 m0;
    403
            bytes32 m1;
    404
            bytes32 m2;
    405
            /// @solidity memory-safe-assembly
    406
            assembly {
    407
                m0 := mload(0x00)
    408
                m1 := mload(0x20)
    409
                m2 := mload(0x40)
    410
                // Selector of `log(uint256,address)`.
    411
                mstore(0x00, 0x69276c86)
    412
                mstore(0x20, p0)
    413
                mstore(0x40, p1)
    414
            }
    415
            _sendLogPayload(0x1c, 0x44);
    416
            /// @solidity memory-safe-assembly
    417
            assembly {
    418
                mstore(0x00, m0)
    419
                mstore(0x20, m1)
    420
                mstore(0x40, m2)
    421
            }
    422
        }
    423
    424
        function log(uint256 p0, bool p1) internal pure {
    425
            bytes32 m0;
    426
            bytes32 m1;
    427
            bytes32 m2;
    428
            /// @solidity memory-safe-assembly
    429
            assembly {
    430
                m0 := mload(0x00)
    431
                m1 := mload(0x20)
    432
                m2 := mload(0x40)
    433
                // Selector of `log(uint256,bool)`.
    434
                mstore(0x00, 0x1c9d7eb3)
    435
                mstore(0x20, p0)
    436
                mstore(0x40, p1)
    437
            }
    438
            _sendLogPayload(0x1c, 0x44);
    439
            /// @solidity memory-safe-assembly
    440
            assembly {
    441
                mstore(0x00, m0)
    442
                mstore(0x20, m1)
    443
                mstore(0x40, m2)
    444
            }
    445
        }
    446
    447
        function log(uint256 p0, uint256 p1) internal pure {
    448
            bytes32 m0;
    449
            bytes32 m1;
    450
            bytes32 m2;
    451
            /// @solidity memory-safe-assembly
    452
            assembly {
    453
                m0 := mload(0x00)
    454
                m1 := mload(0x20)
    455
                m2 := mload(0x40)
    456
                // Selector of `log(uint256,uint256)`.
    457
                mstore(0x00, 0xf666715a)
    458
                mstore(0x20, p0)
    459
                mstore(0x40, p1)
    460
            }
    461
            _sendLogPayload(0x1c, 0x44);
    462
            /// @solidity memory-safe-assembly
    463
            assembly {
    464
                mstore(0x00, m0)
    465
                mstore(0x20, m1)
    466
                mstore(0x40, m2)
    467
            }
    468
        }
    469
    470
        function log(uint256 p0, bytes32 p1) internal pure {
    471
            bytes32 m0;
    472
            bytes32 m1;
    473
            bytes32 m2;
    474
            bytes32 m3;
    475
            bytes32 m4;
    476
            /// @solidity memory-safe-assembly
    477
            assembly {
    478
                function writeString(pos, w) {
    479
                    let length := 0
    480
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    481
                    mstore(pos, length)
    482
                    let shift := sub(256, shl(3, length))
    483
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    484
                }
    485
                m0 := mload(0x00)
    486
                m1 := mload(0x20)
    487
                m2 := mload(0x40)
    488
                m3 := mload(0x60)
    489
                m4 := mload(0x80)
    490
                // Selector of `log(uint256,string)`.
    491
                mstore(0x00, 0x643fd0df)
    492
                mstore(0x20, p0)
    493
                mstore(0x40, 0x40)
    494
                writeString(0x60, p1)
    495
            }
    496
            _sendLogPayload(0x1c, 0x84);
    497
            /// @solidity memory-safe-assembly
    498
            assembly {
    499
                mstore(0x00, m0)
    500
                mstore(0x20, m1)
    501
                mstore(0x40, m2)
    502
                mstore(0x60, m3)
    503
                mstore(0x80, m4)
    504
            }
    505
        }
    506
    507
        function log(bytes32 p0, address p1) internal pure {
    508
            bytes32 m0;
    509
            bytes32 m1;
    510
            bytes32 m2;
    511
            bytes32 m3;
    512
            bytes32 m4;
    513
            /// @solidity memory-safe-assembly
    514
            assembly {
    515
                function writeString(pos, w) {
    516
                    let length := 0
    517
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    518
                    mstore(pos, length)
    519
                    let shift := sub(256, shl(3, length))
    520
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    521
                }
    522
                m0 := mload(0x00)
    523
                m1 := mload(0x20)
    524
                m2 := mload(0x40)
    525
                m3 := mload(0x60)
    526
                m4 := mload(0x80)
    527
                // Selector of `log(string,address)`.
    528
                mstore(0x00, 0x319af333)
    529
                mstore(0x20, 0x40)
    530
                mstore(0x40, p1)
    531
                writeString(0x60, p0)
    532
            }
    533
            _sendLogPayload(0x1c, 0x84);
    534
            /// @solidity memory-safe-assembly
    535
            assembly {
    536
                mstore(0x00, m0)
    537
                mstore(0x20, m1)
    538
                mstore(0x40, m2)
    539
                mstore(0x60, m3)
    540
                mstore(0x80, m4)
    541
            }
    542
        }
    543
    544
        function log(bytes32 p0, bool p1) internal pure {
    545
            bytes32 m0;
    546
            bytes32 m1;
    547
            bytes32 m2;
    548
            bytes32 m3;
    549
            bytes32 m4;
    550
            /// @solidity memory-safe-assembly
    551
            assembly {
    552
                function writeString(pos, w) {
    553
                    let length := 0
    554
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    555
                    mstore(pos, length)
    556
                    let shift := sub(256, shl(3, length))
    557
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    558
                }
    559
                m0 := mload(0x00)
    560
                m1 := mload(0x20)
    561
                m2 := mload(0x40)
    562
                m3 := mload(0x60)
    563
                m4 := mload(0x80)
    564
                // Selector of `log(string,bool)`.
    565
                mstore(0x00, 0xc3b55635)
    566
                mstore(0x20, 0x40)
    567
                mstore(0x40, p1)
    568
                writeString(0x60, p0)
    569
            }
    570
            _sendLogPayload(0x1c, 0x84);
    571
            /// @solidity memory-safe-assembly
    572
            assembly {
    573
                mstore(0x00, m0)
    574
                mstore(0x20, m1)
    575
                mstore(0x40, m2)
    576
                mstore(0x60, m3)
    577
                mstore(0x80, m4)
    578
            }
    579
        }
    580
    581
        function log(bytes32 p0, uint256 p1) internal pure {
    582
            bytes32 m0;
    583
            bytes32 m1;
    584
            bytes32 m2;
    585
            bytes32 m3;
    586
            bytes32 m4;
    587
            /// @solidity memory-safe-assembly
    588
            assembly {
    589
                function writeString(pos, w) {
    590
                    let length := 0
    591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    592
                    mstore(pos, length)
    593
                    let shift := sub(256, shl(3, length))
    594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    595
                }
    596
                m0 := mload(0x00)
    597
                m1 := mload(0x20)
    598
                m2 := mload(0x40)
    599
                m3 := mload(0x60)
    600
                m4 := mload(0x80)
    601
                // Selector of `log(string,uint256)`.
    602
                mstore(0x00, 0xb60e72cc)
    603
                mstore(0x20, 0x40)
    604
                mstore(0x40, p1)
    605
                writeString(0x60, p0)
    606
            }
    607
            _sendLogPayload(0x1c, 0x84);
    608
            /// @solidity memory-safe-assembly
    609
            assembly {
    610
                mstore(0x00, m0)
    611
                mstore(0x20, m1)
    612
                mstore(0x40, m2)
    613
                mstore(0x60, m3)
    614
                mstore(0x80, m4)
    615
            }
    616
        }
    617
    618
        function log(bytes32 p0, bytes32 p1) internal pure {
    619
            bytes32 m0;
    620
            bytes32 m1;
    621
            bytes32 m2;
    622
            bytes32 m3;
    623
            bytes32 m4;
    624
            bytes32 m5;
    625
            bytes32 m6;
    626
            /// @solidity memory-safe-assembly
    627
            assembly {
    628
                function writeString(pos, w) {
    629
                    let length := 0
    630
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    631
                    mstore(pos, length)
    632
                    let shift := sub(256, shl(3, length))
    633
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    634
                }
    635
                m0 := mload(0x00)
    636
                m1 := mload(0x20)
    637
                m2 := mload(0x40)
    638
                m3 := mload(0x60)
    639
                m4 := mload(0x80)
    640
                m5 := mload(0xa0)
    641
                m6 := mload(0xc0)
    642
                // Selector of `log(string,string)`.
    643
                mstore(0x00, 0x4b5c4277)
    644
                mstore(0x20, 0x40)
    645
                mstore(0x40, 0x80)
    646
                writeString(0x60, p0)
    647
                writeString(0xa0, p1)
    648
            }
    649
            _sendLogPayload(0x1c, 0xc4);
    650
            /// @solidity memory-safe-assembly
    651
            assembly {
    652
                mstore(0x00, m0)
    653
                mstore(0x20, m1)
    654
                mstore(0x40, m2)
    655
                mstore(0x60, m3)
    656
                mstore(0x80, m4)
    657
                mstore(0xa0, m5)
    658
                mstore(0xc0, m6)
    659
            }
    660
        }
    661
    662
        function log(address p0, address p1, address p2) internal pure {
    663
            bytes32 m0;
    664
            bytes32 m1;
    665
            bytes32 m2;
    666
            bytes32 m3;
    667
            /// @solidity memory-safe-assembly
    668
            assembly {
    669
                m0 := mload(0x00)
    670
                m1 := mload(0x20)
    671
                m2 := mload(0x40)
    672
                m3 := mload(0x60)
    673
                // Selector of `log(address,address,address)`.
    674
                mstore(0x00, 0x018c84c2)
    675
                mstore(0x20, p0)
    676
                mstore(0x40, p1)
    677
                mstore(0x60, p2)
    678
            }
    679
            _sendLogPayload(0x1c, 0x64);
    680
            /// @solidity memory-safe-assembly
    681
            assembly {
    682
                mstore(0x00, m0)
    683
                mstore(0x20, m1)
    684
                mstore(0x40, m2)
    685
                mstore(0x60, m3)
    686
            }
    687
        }
    688
    689
        function log(address p0, address p1, bool p2) internal pure {
    690
            bytes32 m0;
    691
            bytes32 m1;
    692
            bytes32 m2;
    693
            bytes32 m3;
    694
            /// @solidity memory-safe-assembly
    695
            assembly {
    696
                m0 := mload(0x00)
    697
                m1 := mload(0x20)
    698
                m2 := mload(0x40)
    699
                m3 := mload(0x60)
    700
                // Selector of `log(address,address,bool)`.
    701
                mstore(0x00, 0xf2a66286)
    702
                mstore(0x20, p0)
    703
                mstore(0x40, p1)
    704
                mstore(0x60, p2)
    705
            }
    706
            _sendLogPayload(0x1c, 0x64);
    707
            /// @solidity memory-safe-assembly
    708
            assembly {
    709
                mstore(0x00, m0)
    710
                mstore(0x20, m1)
    711
                mstore(0x40, m2)
    712
                mstore(0x60, m3)
    713
            }
    714
        }
    715
    716
        function log(address p0, address p1, uint256 p2) internal pure {
    717
            bytes32 m0;
    718
            bytes32 m1;
    719
            bytes32 m2;
    720
            bytes32 m3;
    721
            /// @solidity memory-safe-assembly
    722
            assembly {
    723
                m0 := mload(0x00)
    724
                m1 := mload(0x20)
    725
                m2 := mload(0x40)
    726
                m3 := mload(0x60)
    727
                // Selector of `log(address,address,uint256)`.
    728
                mstore(0x00, 0x17fe6185)
    729
                mstore(0x20, p0)
    730
                mstore(0x40, p1)
    731
                mstore(0x60, p2)
    732
            }
    733
            _sendLogPayload(0x1c, 0x64);
    734
            /// @solidity memory-safe-assembly
    735
            assembly {
    736
                mstore(0x00, m0)
    737
                mstore(0x20, m1)
    738
                mstore(0x40, m2)
    739
                mstore(0x60, m3)
    740
            }
    741
        }
    742
    743
        function log(address p0, address p1, bytes32 p2) internal pure {
    744
            bytes32 m0;
    745
            bytes32 m1;
    746
            bytes32 m2;
    747
            bytes32 m3;
    748
            bytes32 m4;
    749
            bytes32 m5;
    750
            /// @solidity memory-safe-assembly
    751
            assembly {
    752
                function writeString(pos, w) {
    753
                    let length := 0
    754
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    755
                    mstore(pos, length)
    756
                    let shift := sub(256, shl(3, length))
    757
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    758
                }
    759
                m0 := mload(0x00)
    760
                m1 := mload(0x20)
    761
                m2 := mload(0x40)
    762
                m3 := mload(0x60)
    763
                m4 := mload(0x80)
    764
                m5 := mload(0xa0)
    765
                // Selector of `log(address,address,string)`.
    766
                mstore(0x00, 0x007150be)
    767
                mstore(0x20, p0)
    768
                mstore(0x40, p1)
    769
                mstore(0x60, 0x60)
    770
                writeString(0x80, p2)
    771
            }
    772
            _sendLogPayload(0x1c, 0xa4);
    773
            /// @solidity memory-safe-assembly
    774
            assembly {
    775
                mstore(0x00, m0)
    776
                mstore(0x20, m1)
    777
                mstore(0x40, m2)
    778
                mstore(0x60, m3)
    779
                mstore(0x80, m4)
    780
                mstore(0xa0, m5)
    781
            }
    782
        }
    783
    784
        function log(address p0, bool p1, address p2) internal pure {
    785
            bytes32 m0;
    786
            bytes32 m1;
    787
            bytes32 m2;
    788
            bytes32 m3;
    789
            /// @solidity memory-safe-assembly
    790
            assembly {
    791
                m0 := mload(0x00)
    792
                m1 := mload(0x20)
    793
                m2 := mload(0x40)
    794
                m3 := mload(0x60)
    795
                // Selector of `log(address,bool,address)`.
    796
                mstore(0x00, 0xf11699ed)
    797
                mstore(0x20, p0)
    798
                mstore(0x40, p1)
    799
                mstore(0x60, p2)
    800
            }
    801
            _sendLogPayload(0x1c, 0x64);
    802
            /// @solidity memory-safe-assembly
    803
            assembly {
    804
                mstore(0x00, m0)
    805
                mstore(0x20, m1)
    806
                mstore(0x40, m2)
    807
                mstore(0x60, m3)
    808
            }
    809
        }
    810
    811
        function log(address p0, bool p1, bool p2) internal pure {
    812
            bytes32 m0;
    813
            bytes32 m1;
    814
            bytes32 m2;
    815
            bytes32 m3;
    816
            /// @solidity memory-safe-assembly
    817
            assembly {
    818
                m0 := mload(0x00)
    819
                m1 := mload(0x20)
    820
                m2 := mload(0x40)
    821
                m3 := mload(0x60)
    822
                // Selector of `log(address,bool,bool)`.
    823
                mstore(0x00, 0xeb830c92)
    824
                mstore(0x20, p0)
    825
                mstore(0x40, p1)
    826
                mstore(0x60, p2)
    827
            }
    828
            _sendLogPayload(0x1c, 0x64);
    829
            /// @solidity memory-safe-assembly
    830
            assembly {
    831
                mstore(0x00, m0)
    832
                mstore(0x20, m1)
    833
                mstore(0x40, m2)
    834
                mstore(0x60, m3)
    835
            }
    836
        }
    837
    838
        function log(address p0, bool p1, uint256 p2) internal pure {
    839
            bytes32 m0;
    840
            bytes32 m1;
    841
            bytes32 m2;
    842
            bytes32 m3;
    843
            /// @solidity memory-safe-assembly
    844
            assembly {
    845
                m0 := mload(0x00)
    846
                m1 := mload(0x20)
    847
                m2 := mload(0x40)
    848
                m3 := mload(0x60)
    849
                // Selector of `log(address,bool,uint256)`.
    850
                mstore(0x00, 0x9c4f99fb)
    851
                mstore(0x20, p0)
    852
                mstore(0x40, p1)
    853
                mstore(0x60, p2)
    854
            }
    855
            _sendLogPayload(0x1c, 0x64);
    856
            /// @solidity memory-safe-assembly
    857
            assembly {
    858
                mstore(0x00, m0)
    859
                mstore(0x20, m1)
    860
                mstore(0x40, m2)
    861
                mstore(0x60, m3)
    862
            }
    863
        }
    864
    865
        function log(address p0, bool p1, bytes32 p2) internal pure {
    866
            bytes32 m0;
    867
            bytes32 m1;
    868
            bytes32 m2;
    869
            bytes32 m3;
    870
            bytes32 m4;
    871
            bytes32 m5;
    872
            /// @solidity memory-safe-assembly
    873
            assembly {
    874
                function writeString(pos, w) {
    875
                    let length := 0
    876
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    877
                    mstore(pos, length)
    878
                    let shift := sub(256, shl(3, length))
    879
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    880
                }
    881
                m0 := mload(0x00)
    882
                m1 := mload(0x20)
    883
                m2 := mload(0x40)
    884
                m3 := mload(0x60)
    885
                m4 := mload(0x80)
    886
                m5 := mload(0xa0)
    887
                // Selector of `log(address,bool,string)`.
    888
                mstore(0x00, 0x212255cc)
    889
                mstore(0x20, p0)
    890
                mstore(0x40, p1)
    891
                mstore(0x60, 0x60)
    892
                writeString(0x80, p2)
    893
            }
    894
            _sendLogPayload(0x1c, 0xa4);
    895
            /// @solidity memory-safe-assembly
    896
            assembly {
    897
                mstore(0x00, m0)
    898
                mstore(0x20, m1)
    899
                mstore(0x40, m2)
    900
                mstore(0x60, m3)
    901
                mstore(0x80, m4)
    902
                mstore(0xa0, m5)
    903
            }
    904
        }
    905
    906
        function log(address p0, uint256 p1, address p2) internal pure {
    907
            bytes32 m0;
    908
            bytes32 m1;
    909
            bytes32 m2;
    910
            bytes32 m3;
    911
            /// @solidity memory-safe-assembly
    912
            assembly {
    913
                m0 := mload(0x00)
    914
                m1 := mload(0x20)
    915
                m2 := mload(0x40)
    916
                m3 := mload(0x60)
    917
                // Selector of `log(address,uint256,address)`.
    918
                mstore(0x00, 0x7bc0d848)
    919
                mstore(0x20, p0)
    920
                mstore(0x40, p1)
    921
                mstore(0x60, p2)
    922
            }
    923
            _sendLogPayload(0x1c, 0x64);
    924
            /// @solidity memory-safe-assembly
    925
            assembly {
    926
                mstore(0x00, m0)
    927
                mstore(0x20, m1)
    928
                mstore(0x40, m2)
    929
                mstore(0x60, m3)
    930
            }
    931
        }
    932
    933
        function log(address p0, uint256 p1, bool p2) internal pure {
    934
            bytes32 m0;
    935
            bytes32 m1;
    936
            bytes32 m2;
    937
            bytes32 m3;
    938
            /// @solidity memory-safe-assembly
    939
            assembly {
    940
                m0 := mload(0x00)
    941
                m1 := mload(0x20)
    942
                m2 := mload(0x40)
    943
                m3 := mload(0x60)
    944
                // Selector of `log(address,uint256,bool)`.
    945
                mstore(0x00, 0x678209a8)
    946
                mstore(0x20, p0)
    947
                mstore(0x40, p1)
    948
                mstore(0x60, p2)
    949
            }
    950
            _sendLogPayload(0x1c, 0x64);
    951
            /// @solidity memory-safe-assembly
    952
            assembly {
    953
                mstore(0x00, m0)
    954
                mstore(0x20, m1)
    955
                mstore(0x40, m2)
    956
                mstore(0x60, m3)
    957
            }
    958
        }
    959
    960
        function log(address p0, uint256 p1, uint256 p2) internal pure {
    961
            bytes32 m0;
    962
            bytes32 m1;
    963
            bytes32 m2;
    964
            bytes32 m3;
    965
            /// @solidity memory-safe-assembly
    966
            assembly {
    967
                m0 := mload(0x00)
    968
                m1 := mload(0x20)
    969
                m2 := mload(0x40)
    970
                m3 := mload(0x60)
    971
                // Selector of `log(address,uint256,uint256)`.
    972
                mstore(0x00, 0xb69bcaf6)
    973
                mstore(0x20, p0)
    974
                mstore(0x40, p1)
    975
                mstore(0x60, p2)
    976
            }
    977
            _sendLogPayload(0x1c, 0x64);
    978
            /// @solidity memory-safe-assembly
    979
            assembly {
    980
                mstore(0x00, m0)
    981
                mstore(0x20, m1)
    982
                mstore(0x40, m2)
    983
                mstore(0x60, m3)
    984
            }
    985
        }
    986
    987
        function log(address p0, uint256 p1, bytes32 p2) internal pure {
    988
            bytes32 m0;
    989
            bytes32 m1;
    990
            bytes32 m2;
    991
            bytes32 m3;
    992
            bytes32 m4;
    993
            bytes32 m5;
    994
            /// @solidity memory-safe-assembly
    995
            assembly {
    996
                function writeString(pos, w) {
    997
                    let length := 0
    998
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    999
                    mstore(pos, length)
    1000
                    let shift := sub(256, shl(3, length))
    1001
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1002
                }
    1003
                m0 := mload(0x00)
    1004
                m1 := mload(0x20)
    1005
                m2 := mload(0x40)
    1006
                m3 := mload(0x60)
    1007
                m4 := mload(0x80)
    1008
                m5 := mload(0xa0)
    1009
                // Selector of `log(address,uint256,string)`.
    1010
                mstore(0x00, 0xa1f2e8aa)
    1011
                mstore(0x20, p0)
    1012
                mstore(0x40, p1)
    1013
                mstore(0x60, 0x60)
    1014
                writeString(0x80, p2)
    1015
            }
    1016
            _sendLogPayload(0x1c, 0xa4);
    1017
            /// @solidity memory-safe-assembly
    1018
            assembly {
    1019
                mstore(0x00, m0)
    1020
                mstore(0x20, m1)
    1021
                mstore(0x40, m2)
    1022
                mstore(0x60, m3)
    1023
                mstore(0x80, m4)
    1024
                mstore(0xa0, m5)
    1025
            }
    1026
        }
    1027
    1028
        function log(address p0, bytes32 p1, address p2) internal pure {
    1029
            bytes32 m0;
    1030
            bytes32 m1;
    1031
            bytes32 m2;
    1032
            bytes32 m3;
    1033
            bytes32 m4;
    1034
            bytes32 m5;
    1035
            /// @solidity memory-safe-assembly
    1036
            assembly {
    1037
                function writeString(pos, w) {
    1038
                    let length := 0
    1039
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1040
                    mstore(pos, length)
    1041
                    let shift := sub(256, shl(3, length))
    1042
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1043
                }
    1044
                m0 := mload(0x00)
    1045
                m1 := mload(0x20)
    1046
                m2 := mload(0x40)
    1047
                m3 := mload(0x60)
    1048
                m4 := mload(0x80)
    1049
                m5 := mload(0xa0)
    1050
                // Selector of `log(address,string,address)`.
    1051
                mstore(0x00, 0xf08744e8)
    1052
                mstore(0x20, p0)
    1053
                mstore(0x40, 0x60)
    1054
                mstore(0x60, p2)
    1055
                writeString(0x80, p1)
    1056
            }
    1057
            _sendLogPayload(0x1c, 0xa4);
    1058
            /// @solidity memory-safe-assembly
    1059
            assembly {
    1060
                mstore(0x00, m0)
    1061
                mstore(0x20, m1)
    1062
                mstore(0x40, m2)
    1063
                mstore(0x60, m3)
    1064
                mstore(0x80, m4)
    1065
                mstore(0xa0, m5)
    1066
            }
    1067
        }
    1068
    1069
        function log(address p0, bytes32 p1, bool p2) internal pure {
    1070
            bytes32 m0;
    1071
            bytes32 m1;
    1072
            bytes32 m2;
    1073
            bytes32 m3;
    1074
            bytes32 m4;
    1075
            bytes32 m5;
    1076
            /// @solidity memory-safe-assembly
    1077
            assembly {
    1078
                function writeString(pos, w) {
    1079
                    let length := 0
    1080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1081
                    mstore(pos, length)
    1082
                    let shift := sub(256, shl(3, length))
    1083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1084
                }
    1085
                m0 := mload(0x00)
    1086
                m1 := mload(0x20)
    1087
                m2 := mload(0x40)
    1088
                m3 := mload(0x60)
    1089
                m4 := mload(0x80)
    1090
                m5 := mload(0xa0)
    1091
                // Selector of `log(address,string,bool)`.
    1092
                mstore(0x00, 0xcf020fb1)
    1093
                mstore(0x20, p0)
    1094
                mstore(0x40, 0x60)
    1095
                mstore(0x60, p2)
    1096
                writeString(0x80, p1)
    1097
            }
    1098
            _sendLogPayload(0x1c, 0xa4);
    1099
            /// @solidity memory-safe-assembly
    1100
            assembly {
    1101
                mstore(0x00, m0)
    1102
                mstore(0x20, m1)
    1103
                mstore(0x40, m2)
    1104
                mstore(0x60, m3)
    1105
                mstore(0x80, m4)
    1106
                mstore(0xa0, m5)
    1107
            }
    1108
        }
    1109
    1110
        function log(address p0, bytes32 p1, uint256 p2) internal pure {
    1111
            bytes32 m0;
    1112
            bytes32 m1;
    1113
            bytes32 m2;
    1114
            bytes32 m3;
    1115
            bytes32 m4;
    1116
            bytes32 m5;
    1117
            /// @solidity memory-safe-assembly
    1118
            assembly {
    1119
                function writeString(pos, w) {
    1120
                    let length := 0
    1121
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1122
                    mstore(pos, length)
    1123
                    let shift := sub(256, shl(3, length))
    1124
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1125
                }
    1126
                m0 := mload(0x00)
    1127
                m1 := mload(0x20)
    1128
                m2 := mload(0x40)
    1129
                m3 := mload(0x60)
    1130
                m4 := mload(0x80)
    1131
                m5 := mload(0xa0)
    1132
                // Selector of `log(address,string,uint256)`.
    1133
                mstore(0x00, 0x67dd6ff1)
    1134
                mstore(0x20, p0)
    1135
                mstore(0x40, 0x60)
    1136
                mstore(0x60, p2)
    1137
                writeString(0x80, p1)
    1138
            }
    1139
            _sendLogPayload(0x1c, 0xa4);
    1140
            /// @solidity memory-safe-assembly
    1141
            assembly {
    1142
                mstore(0x00, m0)
    1143
                mstore(0x20, m1)
    1144
                mstore(0x40, m2)
    1145
                mstore(0x60, m3)
    1146
                mstore(0x80, m4)
    1147
                mstore(0xa0, m5)
    1148
            }
    1149
        }
    1150
    1151
        function log(address p0, bytes32 p1, bytes32 p2) internal pure {
    1152
            bytes32 m0;
    1153
            bytes32 m1;
    1154
            bytes32 m2;
    1155
            bytes32 m3;
    1156
            bytes32 m4;
    1157
            bytes32 m5;
    1158
            bytes32 m6;
    1159
            bytes32 m7;
    1160
            /// @solidity memory-safe-assembly
    1161
            assembly {
    1162
                function writeString(pos, w) {
    1163
                    let length := 0
    1164
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1165
                    mstore(pos, length)
    1166
                    let shift := sub(256, shl(3, length))
    1167
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1168
                }
    1169
                m0 := mload(0x00)
    1170
                m1 := mload(0x20)
    1171
                m2 := mload(0x40)
    1172
                m3 := mload(0x60)
    1173
                m4 := mload(0x80)
    1174
                m5 := mload(0xa0)
    1175
                m6 := mload(0xc0)
    1176
                m7 := mload(0xe0)
    1177
                // Selector of `log(address,string,string)`.
    1178
                mstore(0x00, 0xfb772265)
    1179
                mstore(0x20, p0)
    1180
                mstore(0x40, 0x60)
    1181
                mstore(0x60, 0xa0)
    1182
                writeString(0x80, p1)
    1183
                writeString(0xc0, p2)
    1184
            }
    1185
            _sendLogPayload(0x1c, 0xe4);
    1186
            /// @solidity memory-safe-assembly
    1187
            assembly {
    1188
                mstore(0x00, m0)
    1189
                mstore(0x20, m1)
    1190
                mstore(0x40, m2)
    1191
                mstore(0x60, m3)
    1192
                mstore(0x80, m4)
    1193
                mstore(0xa0, m5)
    1194
                mstore(0xc0, m6)
    1195
                mstore(0xe0, m7)
    1196
            }
    1197
        }
    1198
    1199
        function log(bool p0, address p1, address p2) internal pure {
    1200
            bytes32 m0;
    1201
            bytes32 m1;
    1202
            bytes32 m2;
    1203
            bytes32 m3;
    1204
            /// @solidity memory-safe-assembly
    1205
            assembly {
    1206
                m0 := mload(0x00)
    1207
                m1 := mload(0x20)
    1208
                m2 := mload(0x40)
    1209
                m3 := mload(0x60)
    1210
                // Selector of `log(bool,address,address)`.
    1211
                mstore(0x00, 0xd2763667)
    1212
                mstore(0x20, p0)
    1213
                mstore(0x40, p1)
    1214
                mstore(0x60, p2)
    1215
            }
    1216
            _sendLogPayload(0x1c, 0x64);
    1217
            /// @solidity memory-safe-assembly
    1218
            assembly {
    1219
                mstore(0x00, m0)
    1220
                mstore(0x20, m1)
    1221
                mstore(0x40, m2)
    1222
                mstore(0x60, m3)
    1223
            }
    1224
        }
    1225
    1226
        function log(bool p0, address p1, bool p2) internal pure {
    1227
            bytes32 m0;
    1228
            bytes32 m1;
    1229
            bytes32 m2;
    1230
            bytes32 m3;
    1231
            /// @solidity memory-safe-assembly
    1232
            assembly {
    1233
                m0 := mload(0x00)
    1234
                m1 := mload(0x20)
    1235
                m2 := mload(0x40)
    1236
                m3 := mload(0x60)
    1237
                // Selector of `log(bool,address,bool)`.
    1238
                mstore(0x00, 0x18c9c746)
    1239
                mstore(0x20, p0)
    1240
                mstore(0x40, p1)
    1241
                mstore(0x60, p2)
    1242
            }
    1243
            _sendLogPayload(0x1c, 0x64);
    1244
            /// @solidity memory-safe-assembly
    1245
            assembly {
    1246
                mstore(0x00, m0)
    1247
                mstore(0x20, m1)
    1248
                mstore(0x40, m2)
    1249
                mstore(0x60, m3)
    1250
            }
    1251
        }
    1252
    1253
        function log(bool p0, address p1, uint256 p2) internal pure {
    1254
            bytes32 m0;
    1255
            bytes32 m1;
    1256
            bytes32 m2;
    1257
            bytes32 m3;
    1258
            /// @solidity memory-safe-assembly
    1259
            assembly {
    1260
                m0 := mload(0x00)
    1261
                m1 := mload(0x20)
    1262
                m2 := mload(0x40)
    1263
                m3 := mload(0x60)
    1264
                // Selector of `log(bool,address,uint256)`.
    1265
                mstore(0x00, 0x5f7b9afb)
    1266
                mstore(0x20, p0)
    1267
                mstore(0x40, p1)
    1268
                mstore(0x60, p2)
    1269
            }
    1270
            _sendLogPayload(0x1c, 0x64);
    1271
            /// @solidity memory-safe-assembly
    1272
            assembly {
    1273
                mstore(0x00, m0)
    1274
                mstore(0x20, m1)
    1275
                mstore(0x40, m2)
    1276
                mstore(0x60, m3)
    1277
            }
    1278
        }
    1279
    1280
        function log(bool p0, address p1, bytes32 p2) internal pure {
    1281
            bytes32 m0;
    1282
            bytes32 m1;
    1283
            bytes32 m2;
    1284
            bytes32 m3;
    1285
            bytes32 m4;
    1286
            bytes32 m5;
    1287
            /// @solidity memory-safe-assembly
    1288
            assembly {
    1289
                function writeString(pos, w) {
    1290
                    let length := 0
    1291
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1292
                    mstore(pos, length)
    1293
                    let shift := sub(256, shl(3, length))
    1294
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1295
                }
    1296
                m0 := mload(0x00)
    1297
                m1 := mload(0x20)
    1298
                m2 := mload(0x40)
    1299
                m3 := mload(0x60)
    1300
                m4 := mload(0x80)
    1301
                m5 := mload(0xa0)
    1302
                // Selector of `log(bool,address,string)`.
    1303
                mstore(0x00, 0xde9a9270)
    1304
                mstore(0x20, p0)
    1305
                mstore(0x40, p1)
    1306
                mstore(0x60, 0x60)
    1307
                writeString(0x80, p2)
    1308
            }
    1309
            _sendLogPayload(0x1c, 0xa4);
    1310
            /// @solidity memory-safe-assembly
    1311
            assembly {
    1312
                mstore(0x00, m0)
    1313
                mstore(0x20, m1)
    1314
                mstore(0x40, m2)
    1315
                mstore(0x60, m3)
    1316
                mstore(0x80, m4)
    1317
                mstore(0xa0, m5)
    1318
            }
    1319
        }
    1320
    1321
        function log(bool p0, bool p1, address p2) internal pure {
    1322
            bytes32 m0;
    1323
            bytes32 m1;
    1324
            bytes32 m2;
    1325
            bytes32 m3;
    1326
            /// @solidity memory-safe-assembly
    1327
            assembly {
    1328
                m0 := mload(0x00)
    1329
                m1 := mload(0x20)
    1330
                m2 := mload(0x40)
    1331
                m3 := mload(0x60)
    1332
                // Selector of `log(bool,bool,address)`.
    1333
                mstore(0x00, 0x1078f68d)
    1334
                mstore(0x20, p0)
    1335
                mstore(0x40, p1)
    1336
                mstore(0x60, p2)
    1337
            }
    1338
            _sendLogPayload(0x1c, 0x64);
    1339
            /// @solidity memory-safe-assembly
    1340
            assembly {
    1341
                mstore(0x00, m0)
    1342
                mstore(0x20, m1)
    1343
                mstore(0x40, m2)
    1344
                mstore(0x60, m3)
    1345
            }
    1346
        }
    1347
    1348
        function log(bool p0, bool p1, bool p2) internal pure {
    1349
            bytes32 m0;
    1350
            bytes32 m1;
    1351
            bytes32 m2;
    1352
            bytes32 m3;
    1353
            /// @solidity memory-safe-assembly
    1354
            assembly {
    1355
                m0 := mload(0x00)
    1356
                m1 := mload(0x20)
    1357
                m2 := mload(0x40)
    1358
                m3 := mload(0x60)
    1359
                // Selector of `log(bool,bool,bool)`.
    1360
                mstore(0x00, 0x50709698)
    1361
                mstore(0x20, p0)
    1362
                mstore(0x40, p1)
    1363
                mstore(0x60, p2)
    1364
            }
    1365
            _sendLogPayload(0x1c, 0x64);
    1366
            /// @solidity memory-safe-assembly
    1367
            assembly {
    1368
                mstore(0x00, m0)
    1369
                mstore(0x20, m1)
    1370
                mstore(0x40, m2)
    1371
                mstore(0x60, m3)
    1372
            }
    1373
        }
    1374
    1375
        function log(bool p0, bool p1, uint256 p2) internal pure {
    1376
            bytes32 m0;
    1377
            bytes32 m1;
    1378
            bytes32 m2;
    1379
            bytes32 m3;
    1380
            /// @solidity memory-safe-assembly
    1381
            assembly {
    1382
                m0 := mload(0x00)
    1383
                m1 := mload(0x20)
    1384
                m2 := mload(0x40)
    1385
                m3 := mload(0x60)
    1386
                // Selector of `log(bool,bool,uint256)`.
    1387
                mstore(0x00, 0x12f21602)
    1388
                mstore(0x20, p0)
    1389
                mstore(0x40, p1)
    1390
                mstore(0x60, p2)
    1391
            }
    1392
            _sendLogPayload(0x1c, 0x64);
    1393
            /// @solidity memory-safe-assembly
    1394
            assembly {
    1395
                mstore(0x00, m0)
    1396
                mstore(0x20, m1)
    1397
                mstore(0x40, m2)
    1398
                mstore(0x60, m3)
    1399
            }
    1400
        }
    1401
    1402
        function log(bool p0, bool p1, bytes32 p2) internal pure {
    1403
            bytes32 m0;
    1404
            bytes32 m1;
    1405
            bytes32 m2;
    1406
            bytes32 m3;
    1407
            bytes32 m4;
    1408
            bytes32 m5;
    1409
            /// @solidity memory-safe-assembly
    1410
            assembly {
    1411
                function writeString(pos, w) {
    1412
                    let length := 0
    1413
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1414
                    mstore(pos, length)
    1415
                    let shift := sub(256, shl(3, length))
    1416
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1417
                }
    1418
                m0 := mload(0x00)
    1419
                m1 := mload(0x20)
    1420
                m2 := mload(0x40)
    1421
                m3 := mload(0x60)
    1422
                m4 := mload(0x80)
    1423
                m5 := mload(0xa0)
    1424
                // Selector of `log(bool,bool,string)`.
    1425
                mstore(0x00, 0x2555fa46)
    1426
                mstore(0x20, p0)
    1427
                mstore(0x40, p1)
    1428
                mstore(0x60, 0x60)
    1429
                writeString(0x80, p2)
    1430
            }
    1431
            _sendLogPayload(0x1c, 0xa4);
    1432
            /// @solidity memory-safe-assembly
    1433
            assembly {
    1434
                mstore(0x00, m0)
    1435
                mstore(0x20, m1)
    1436
                mstore(0x40, m2)
    1437
                mstore(0x60, m3)
    1438
                mstore(0x80, m4)
    1439
                mstore(0xa0, m5)
    1440
            }
    1441
        }
    1442
    1443
        function log(bool p0, uint256 p1, address p2) internal pure {
    1444
            bytes32 m0;
    1445
            bytes32 m1;
    1446
            bytes32 m2;
    1447
            bytes32 m3;
    1448
            /// @solidity memory-safe-assembly
    1449
            assembly {
    1450
                m0 := mload(0x00)
    1451
                m1 := mload(0x20)
    1452
                m2 := mload(0x40)
    1453
                m3 := mload(0x60)
    1454
                // Selector of `log(bool,uint256,address)`.
    1455
                mstore(0x00, 0x088ef9d2)
    1456
                mstore(0x20, p0)
    1457
                mstore(0x40, p1)
    1458
                mstore(0x60, p2)
    1459
            }
    1460
            _sendLogPayload(0x1c, 0x64);
    1461
            /// @solidity memory-safe-assembly
    1462
            assembly {
    1463
                mstore(0x00, m0)
    1464
                mstore(0x20, m1)
    1465
                mstore(0x40, m2)
    1466
                mstore(0x60, m3)
    1467
            }
    1468
        }
    1469
    1470
        function log(bool p0, uint256 p1, bool p2) internal pure {
    1471
            bytes32 m0;
    1472
            bytes32 m1;
    1473
            bytes32 m2;
    1474
            bytes32 m3;
    1475
            /// @solidity memory-safe-assembly
    1476
            assembly {
    1477
                m0 := mload(0x00)
    1478
                m1 := mload(0x20)
    1479
                m2 := mload(0x40)
    1480
                m3 := mload(0x60)
    1481
                // Selector of `log(bool,uint256,bool)`.
    1482
                mstore(0x00, 0xe8defba9)
    1483
                mstore(0x20, p0)
    1484
                mstore(0x40, p1)
    1485
                mstore(0x60, p2)
    1486
            }
    1487
            _sendLogPayload(0x1c, 0x64);
    1488
            /// @solidity memory-safe-assembly
    1489
            assembly {
    1490
                mstore(0x00, m0)
    1491
                mstore(0x20, m1)
    1492
                mstore(0x40, m2)
    1493
                mstore(0x60, m3)
    1494
            }
    1495
        }
    1496
    1497
        function log(bool p0, uint256 p1, uint256 p2) internal pure {
    1498
            bytes32 m0;
    1499
            bytes32 m1;
    1500
            bytes32 m2;
    1501
            bytes32 m3;
    1502
            /// @solidity memory-safe-assembly
    1503
            assembly {
    1504
                m0 := mload(0x00)
    1505
                m1 := mload(0x20)
    1506
                m2 := mload(0x40)
    1507
                m3 := mload(0x60)
    1508
                // Selector of `log(bool,uint256,uint256)`.
    1509
                mstore(0x00, 0x37103367)
    1510
                mstore(0x20, p0)
    1511
                mstore(0x40, p1)
    1512
                mstore(0x60, p2)
    1513
            }
    1514
            _sendLogPayload(0x1c, 0x64);
    1515
            /// @solidity memory-safe-assembly
    1516
            assembly {
    1517
                mstore(0x00, m0)
    1518
                mstore(0x20, m1)
    1519
                mstore(0x40, m2)
    1520
                mstore(0x60, m3)
    1521
            }
    1522
        }
    1523
    1524
        function log(bool p0, uint256 p1, bytes32 p2) internal pure {
    1525
            bytes32 m0;
    1526
            bytes32 m1;
    1527
            bytes32 m2;
    1528
            bytes32 m3;
    1529
            bytes32 m4;
    1530
            bytes32 m5;
    1531
            /// @solidity memory-safe-assembly
    1532
            assembly {
    1533
                function writeString(pos, w) {
    1534
                    let length := 0
    1535
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1536
                    mstore(pos, length)
    1537
                    let shift := sub(256, shl(3, length))
    1538
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1539
                }
    1540
                m0 := mload(0x00)
    1541
                m1 := mload(0x20)
    1542
                m2 := mload(0x40)
    1543
                m3 := mload(0x60)
    1544
                m4 := mload(0x80)
    1545
                m5 := mload(0xa0)
    1546
                // Selector of `log(bool,uint256,string)`.
    1547
                mstore(0x00, 0xc3fc3970)
    1548
                mstore(0x20, p0)
    1549
                mstore(0x40, p1)
    1550
                mstore(0x60, 0x60)
    1551
                writeString(0x80, p2)
    1552
            }
    1553
            _sendLogPayload(0x1c, 0xa4);
    1554
            /// @solidity memory-safe-assembly
    1555
            assembly {
    1556
                mstore(0x00, m0)
    1557
                mstore(0x20, m1)
    1558
                mstore(0x40, m2)
    1559
                mstore(0x60, m3)
    1560
                mstore(0x80, m4)
    1561
                mstore(0xa0, m5)
    1562
            }
    1563
        }
    1564
    1565
        function log(bool p0, bytes32 p1, address p2) internal pure {
    1566
            bytes32 m0;
    1567
            bytes32 m1;
    1568
            bytes32 m2;
    1569
            bytes32 m3;
    1570
            bytes32 m4;
    1571
            bytes32 m5;
    1572
            /// @solidity memory-safe-assembly
    1573
            assembly {
    1574
                function writeString(pos, w) {
    1575
                    let length := 0
    1576
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1577
                    mstore(pos, length)
    1578
                    let shift := sub(256, shl(3, length))
    1579
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1580
                }
    1581
                m0 := mload(0x00)
    1582
                m1 := mload(0x20)
    1583
                m2 := mload(0x40)
    1584
                m3 := mload(0x60)
    1585
                m4 := mload(0x80)
    1586
                m5 := mload(0xa0)
    1587
                // Selector of `log(bool,string,address)`.
    1588
                mstore(0x00, 0x9591b953)
    1589
                mstore(0x20, p0)
    1590
                mstore(0x40, 0x60)
    1591
                mstore(0x60, p2)
    1592
                writeString(0x80, p1)
    1593
            }
    1594
            _sendLogPayload(0x1c, 0xa4);
    1595
            /// @solidity memory-safe-assembly
    1596
            assembly {
    1597
                mstore(0x00, m0)
    1598
                mstore(0x20, m1)
    1599
                mstore(0x40, m2)
    1600
                mstore(0x60, m3)
    1601
                mstore(0x80, m4)
    1602
                mstore(0xa0, m5)
    1603
            }
    1604
        }
    1605
    1606
        function log(bool p0, bytes32 p1, bool p2) internal pure {
    1607
            bytes32 m0;
    1608
            bytes32 m1;
    1609
            bytes32 m2;
    1610
            bytes32 m3;
    1611
            bytes32 m4;
    1612
            bytes32 m5;
    1613
            /// @solidity memory-safe-assembly
    1614
            assembly {
    1615
                function writeString(pos, w) {
    1616
                    let length := 0
    1617
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1618
                    mstore(pos, length)
    1619
                    let shift := sub(256, shl(3, length))
    1620
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1621
                }
    1622
                m0 := mload(0x00)
    1623
                m1 := mload(0x20)
    1624
                m2 := mload(0x40)
    1625
                m3 := mload(0x60)
    1626
                m4 := mload(0x80)
    1627
                m5 := mload(0xa0)
    1628
                // Selector of `log(bool,string,bool)`.
    1629
                mstore(0x00, 0xdbb4c247)
    1630
                mstore(0x20, p0)
    1631
                mstore(0x40, 0x60)
    1632
                mstore(0x60, p2)
    1633
                writeString(0x80, p1)
    1634
            }
    1635
            _sendLogPayload(0x1c, 0xa4);
    1636
            /// @solidity memory-safe-assembly
    1637
            assembly {
    1638
                mstore(0x00, m0)
    1639
                mstore(0x20, m1)
    1640
                mstore(0x40, m2)
    1641
                mstore(0x60, m3)
    1642
                mstore(0x80, m4)
    1643
                mstore(0xa0, m5)
    1644
            }
    1645
        }
    1646
    1647
        function log(bool p0, bytes32 p1, uint256 p2) internal pure {
    1648
            bytes32 m0;
    1649
            bytes32 m1;
    1650
            bytes32 m2;
    1651
            bytes32 m3;
    1652
            bytes32 m4;
    1653
            bytes32 m5;
    1654
            /// @solidity memory-safe-assembly
    1655
            assembly {
    1656
                function writeString(pos, w) {
    1657
                    let length := 0
    1658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1659
                    mstore(pos, length)
    1660
                    let shift := sub(256, shl(3, length))
    1661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1662
                }
    1663
                m0 := mload(0x00)
    1664
                m1 := mload(0x20)
    1665
                m2 := mload(0x40)
    1666
                m3 := mload(0x60)
    1667
                m4 := mload(0x80)
    1668
                m5 := mload(0xa0)
    1669
                // Selector of `log(bool,string,uint256)`.
    1670
                mstore(0x00, 0x1093ee11)
    1671
                mstore(0x20, p0)
    1672
                mstore(0x40, 0x60)
    1673
                mstore(0x60, p2)
    1674
                writeString(0x80, p1)
    1675
            }
    1676
            _sendLogPayload(0x1c, 0xa4);
    1677
            /// @solidity memory-safe-assembly
    1678
            assembly {
    1679
                mstore(0x00, m0)
    1680
                mstore(0x20, m1)
    1681
                mstore(0x40, m2)
    1682
                mstore(0x60, m3)
    1683
                mstore(0x80, m4)
    1684
                mstore(0xa0, m5)
    1685
            }
    1686
        }
    1687
    1688
        function log(bool p0, bytes32 p1, bytes32 p2) internal pure {
    1689
            bytes32 m0;
    1690
            bytes32 m1;
    1691
            bytes32 m2;
    1692
            bytes32 m3;
    1693
            bytes32 m4;
    1694
            bytes32 m5;
    1695
            bytes32 m6;
    1696
            bytes32 m7;
    1697
            /// @solidity memory-safe-assembly
    1698
            assembly {
    1699
                function writeString(pos, w) {
    1700
                    let length := 0
    1701
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1702
                    mstore(pos, length)
    1703
                    let shift := sub(256, shl(3, length))
    1704
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1705
                }
    1706
                m0 := mload(0x00)
    1707
                m1 := mload(0x20)
    1708
                m2 := mload(0x40)
    1709
                m3 := mload(0x60)
    1710
                m4 := mload(0x80)
    1711
                m5 := mload(0xa0)
    1712
                m6 := mload(0xc0)
    1713
                m7 := mload(0xe0)
    1714
                // Selector of `log(bool,string,string)`.
    1715
                mstore(0x00, 0xb076847f)
    1716
                mstore(0x20, p0)
    1717
                mstore(0x40, 0x60)
    1718
                mstore(0x60, 0xa0)
    1719
                writeString(0x80, p1)
    1720
                writeString(0xc0, p2)
    1721
            }
    1722
            _sendLogPayload(0x1c, 0xe4);
    1723
            /// @solidity memory-safe-assembly
    1724
            assembly {
    1725
                mstore(0x00, m0)
    1726
                mstore(0x20, m1)
    1727
                mstore(0x40, m2)
    1728
                mstore(0x60, m3)
    1729
                mstore(0x80, m4)
    1730
                mstore(0xa0, m5)
    1731
                mstore(0xc0, m6)
    1732
                mstore(0xe0, m7)
    1733
            }
    1734
        }
    1735
    1736
        function log(uint256 p0, address p1, address p2) internal pure {
    1737
            bytes32 m0;
    1738
            bytes32 m1;
    1739
            bytes32 m2;
    1740
            bytes32 m3;
    1741
            /// @solidity memory-safe-assembly
    1742
            assembly {
    1743
                m0 := mload(0x00)
    1744
                m1 := mload(0x20)
    1745
                m2 := mload(0x40)
    1746
                m3 := mload(0x60)
    1747
                // Selector of `log(uint256,address,address)`.
    1748
                mstore(0x00, 0xbcfd9be0)
    1749
                mstore(0x20, p0)
    1750
                mstore(0x40, p1)
    1751
                mstore(0x60, p2)
    1752
            }
    1753
            _sendLogPayload(0x1c, 0x64);
    1754
            /// @solidity memory-safe-assembly
    1755
            assembly {
    1756
                mstore(0x00, m0)
    1757
                mstore(0x20, m1)
    1758
                mstore(0x40, m2)
    1759
                mstore(0x60, m3)
    1760
            }
    1761
        }
    1762
    1763
        function log(uint256 p0, address p1, bool p2) internal pure {
    1764
            bytes32 m0;
    1765
            bytes32 m1;
    1766
            bytes32 m2;
    1767
            bytes32 m3;
    1768
            /// @solidity memory-safe-assembly
    1769
            assembly {
    1770
                m0 := mload(0x00)
    1771
                m1 := mload(0x20)
    1772
                m2 := mload(0x40)
    1773
                m3 := mload(0x60)
    1774
                // Selector of `log(uint256,address,bool)`.
    1775
                mstore(0x00, 0x9b6ec042)
    1776
                mstore(0x20, p0)
    1777
                mstore(0x40, p1)
    1778
                mstore(0x60, p2)
    1779
            }
    1780
            _sendLogPayload(0x1c, 0x64);
    1781
            /// @solidity memory-safe-assembly
    1782
            assembly {
    1783
                mstore(0x00, m0)
    1784
                mstore(0x20, m1)
    1785
                mstore(0x40, m2)
    1786
                mstore(0x60, m3)
    1787
            }
    1788
        }
    1789
    1790
        function log(uint256 p0, address p1, uint256 p2) internal pure {
    1791
            bytes32 m0;
    1792
            bytes32 m1;
    1793
            bytes32 m2;
    1794
            bytes32 m3;
    1795
            /// @solidity memory-safe-assembly
    1796
            assembly {
    1797
                m0 := mload(0x00)
    1798
                m1 := mload(0x20)
    1799
                m2 := mload(0x40)
    1800
                m3 := mload(0x60)
    1801
                // Selector of `log(uint256,address,uint256)`.
    1802
                mstore(0x00, 0x5a9b5ed5)
    1803
                mstore(0x20, p0)
    1804
                mstore(0x40, p1)
    1805
                mstore(0x60, p2)
    1806
            }
    1807
            _sendLogPayload(0x1c, 0x64);
    1808
            /// @solidity memory-safe-assembly
    1809
            assembly {
    1810
                mstore(0x00, m0)
    1811
                mstore(0x20, m1)
    1812
                mstore(0x40, m2)
    1813
                mstore(0x60, m3)
    1814
            }
    1815
        }
    1816
    1817
        function log(uint256 p0, address p1, bytes32 p2) internal pure {
    1818
            bytes32 m0;
    1819
            bytes32 m1;
    1820
            bytes32 m2;
    1821
            bytes32 m3;
    1822
            bytes32 m4;
    1823
            bytes32 m5;
    1824
            /// @solidity memory-safe-assembly
    1825
            assembly {
    1826
                function writeString(pos, w) {
    1827
                    let length := 0
    1828
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1829
                    mstore(pos, length)
    1830
                    let shift := sub(256, shl(3, length))
    1831
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1832
                }
    1833
                m0 := mload(0x00)
    1834
                m1 := mload(0x20)
    1835
                m2 := mload(0x40)
    1836
                m3 := mload(0x60)
    1837
                m4 := mload(0x80)
    1838
                m5 := mload(0xa0)
    1839
                // Selector of `log(uint256,address,string)`.
    1840
                mstore(0x00, 0x63cb41f9)
    1841
                mstore(0x20, p0)
    1842
                mstore(0x40, p1)
    1843
                mstore(0x60, 0x60)
    1844
                writeString(0x80, p2)
    1845
            }
    1846
            _sendLogPayload(0x1c, 0xa4);
    1847
            /// @solidity memory-safe-assembly
    1848
            assembly {
    1849
                mstore(0x00, m0)
    1850
                mstore(0x20, m1)
    1851
                mstore(0x40, m2)
    1852
                mstore(0x60, m3)
    1853
                mstore(0x80, m4)
    1854
                mstore(0xa0, m5)
    1855
            }
    1856
        }
    1857
    1858
        function log(uint256 p0, bool p1, address p2) internal pure {
    1859
            bytes32 m0;
    1860
            bytes32 m1;
    1861
            bytes32 m2;
    1862
            bytes32 m3;
    1863
            /// @solidity memory-safe-assembly
    1864
            assembly {
    1865
                m0 := mload(0x00)
    1866
                m1 := mload(0x20)
    1867
                m2 := mload(0x40)
    1868
                m3 := mload(0x60)
    1869
                // Selector of `log(uint256,bool,address)`.
    1870
                mstore(0x00, 0x35085f7b)
    1871
                mstore(0x20, p0)
    1872
                mstore(0x40, p1)
    1873
                mstore(0x60, p2)
    1874
            }
    1875
            _sendLogPayload(0x1c, 0x64);
    1876
            /// @solidity memory-safe-assembly
    1877
            assembly {
    1878
                mstore(0x00, m0)
    1879
                mstore(0x20, m1)
    1880
                mstore(0x40, m2)
    1881
                mstore(0x60, m3)
    1882
            }
    1883
        }
    1884
    1885
        function log(uint256 p0, bool p1, bool p2) internal pure {
    1886
            bytes32 m0;
    1887
            bytes32 m1;
    1888
            bytes32 m2;
    1889
            bytes32 m3;
    1890
            /// @solidity memory-safe-assembly
    1891
            assembly {
    1892
                m0 := mload(0x00)
    1893
                m1 := mload(0x20)
    1894
                m2 := mload(0x40)
    1895
                m3 := mload(0x60)
    1896
                // Selector of `log(uint256,bool,bool)`.
    1897
                mstore(0x00, 0x20718650)
    1898
                mstore(0x20, p0)
    1899
                mstore(0x40, p1)
    1900
                mstore(0x60, p2)
    1901
            }
    1902
            _sendLogPayload(0x1c, 0x64);
    1903
            /// @solidity memory-safe-assembly
    1904
            assembly {
    1905
                mstore(0x00, m0)
    1906
                mstore(0x20, m1)
    1907
                mstore(0x40, m2)
    1908
                mstore(0x60, m3)
    1909
            }
    1910
        }
    1911
    1912
        function log(uint256 p0, bool p1, uint256 p2) internal pure {
    1913
            bytes32 m0;
    1914
            bytes32 m1;
    1915
            bytes32 m2;
    1916
            bytes32 m3;
    1917
            /// @solidity memory-safe-assembly
    1918
            assembly {
    1919
                m0 := mload(0x00)
    1920
                m1 := mload(0x20)
    1921
                m2 := mload(0x40)
    1922
                m3 := mload(0x60)
    1923
                // Selector of `log(uint256,bool,uint256)`.
    1924
                mstore(0x00, 0x20098014)
    1925
                mstore(0x20, p0)
    1926
                mstore(0x40, p1)
    1927
                mstore(0x60, p2)
    1928
            }
    1929
            _sendLogPayload(0x1c, 0x64);
    1930
            /// @solidity memory-safe-assembly
    1931
            assembly {
    1932
                mstore(0x00, m0)
    1933
                mstore(0x20, m1)
    1934
                mstore(0x40, m2)
    1935
                mstore(0x60, m3)
    1936
            }
    1937
        }
    1938
    1939
        function log(uint256 p0, bool p1, bytes32 p2) internal pure {
    1940
            bytes32 m0;
    1941
            bytes32 m1;
    1942
            bytes32 m2;
    1943
            bytes32 m3;
    1944
            bytes32 m4;
    1945
            bytes32 m5;
    1946
            /// @solidity memory-safe-assembly
    1947
            assembly {
    1948
                function writeString(pos, w) {
    1949
                    let length := 0
    1950
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    1951
                    mstore(pos, length)
    1952
                    let shift := sub(256, shl(3, length))
    1953
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    1954
                }
    1955
                m0 := mload(0x00)
    1956
                m1 := mload(0x20)
    1957
                m2 := mload(0x40)
    1958
                m3 := mload(0x60)
    1959
                m4 := mload(0x80)
    1960
                m5 := mload(0xa0)
    1961
                // Selector of `log(uint256,bool,string)`.
    1962
                mstore(0x00, 0x85775021)
    1963
                mstore(0x20, p0)
    1964
                mstore(0x40, p1)
    1965
                mstore(0x60, 0x60)
    1966
                writeString(0x80, p2)
    1967
            }
    1968
            _sendLogPayload(0x1c, 0xa4);
    1969
            /// @solidity memory-safe-assembly
    1970
            assembly {
    1971
                mstore(0x00, m0)
    1972
                mstore(0x20, m1)
    1973
                mstore(0x40, m2)
    1974
                mstore(0x60, m3)
    1975
                mstore(0x80, m4)
    1976
                mstore(0xa0, m5)
    1977
            }
    1978
        }
    1979
    1980
        function log(uint256 p0, uint256 p1, address p2) internal pure {
    1981
            bytes32 m0;
    1982
            bytes32 m1;
    1983
            bytes32 m2;
    1984
            bytes32 m3;
    1985
            /// @solidity memory-safe-assembly
    1986
            assembly {
    1987
                m0 := mload(0x00)
    1988
                m1 := mload(0x20)
    1989
                m2 := mload(0x40)
    1990
                m3 := mload(0x60)
    1991
                // Selector of `log(uint256,uint256,address)`.
    1992
                mstore(0x00, 0x5c96b331)
    1993
                mstore(0x20, p0)
    1994
                mstore(0x40, p1)
    1995
                mstore(0x60, p2)
    1996
            }
    1997
            _sendLogPayload(0x1c, 0x64);
    1998
            /// @solidity memory-safe-assembly
    1999
            assembly {
    2000
                mstore(0x00, m0)
    2001
                mstore(0x20, m1)
    2002
                mstore(0x40, m2)
    2003
                mstore(0x60, m3)
    2004
            }
    2005
        }
    2006
    2007
        function log(uint256 p0, uint256 p1, bool p2) internal pure {
    2008
            bytes32 m0;
    2009
            bytes32 m1;
    2010
            bytes32 m2;
    2011
            bytes32 m3;
    2012
            /// @solidity memory-safe-assembly
    2013
            assembly {
    2014
                m0 := mload(0x00)
    2015
                m1 := mload(0x20)
    2016
                m2 := mload(0x40)
    2017
                m3 := mload(0x60)
    2018
                // Selector of `log(uint256,uint256,bool)`.
    2019
                mstore(0x00, 0x4766da72)
    2020
                mstore(0x20, p0)
    2021
                mstore(0x40, p1)
    2022
                mstore(0x60, p2)
    2023
            }
    2024
            _sendLogPayload(0x1c, 0x64);
    2025
            /// @solidity memory-safe-assembly
    2026
            assembly {
    2027
                mstore(0x00, m0)
    2028
                mstore(0x20, m1)
    2029
                mstore(0x40, m2)
    2030
                mstore(0x60, m3)
    2031
            }
    2032
        }
    2033
    2034
        function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
    2035
            bytes32 m0;
    2036
            bytes32 m1;
    2037
            bytes32 m2;
    2038
            bytes32 m3;
    2039
            /// @solidity memory-safe-assembly
    2040
            assembly {
    2041
                m0 := mload(0x00)
    2042
                m1 := mload(0x20)
    2043
                m2 := mload(0x40)
    2044
                m3 := mload(0x60)
    2045
                // Selector of `log(uint256,uint256,uint256)`.
    2046
                mstore(0x00, 0xd1ed7a3c)
    2047
                mstore(0x20, p0)
    2048
                mstore(0x40, p1)
    2049
                mstore(0x60, p2)
    2050
            }
    2051
            _sendLogPayload(0x1c, 0x64);
    2052
            /// @solidity memory-safe-assembly
    2053
            assembly {
    2054
                mstore(0x00, m0)
    2055
                mstore(0x20, m1)
    2056
                mstore(0x40, m2)
    2057
                mstore(0x60, m3)
    2058
            }
    2059
        }
    2060
    2061
        function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {
    2062
            bytes32 m0;
    2063
            bytes32 m1;
    2064
            bytes32 m2;
    2065
            bytes32 m3;
    2066
            bytes32 m4;
    2067
            bytes32 m5;
    2068
            /// @solidity memory-safe-assembly
    2069
            assembly {
    2070
                function writeString(pos, w) {
    2071
                    let length := 0
    2072
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2073
                    mstore(pos, length)
    2074
                    let shift := sub(256, shl(3, length))
    2075
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2076
                }
    2077
                m0 := mload(0x00)
    2078
                m1 := mload(0x20)
    2079
                m2 := mload(0x40)
    2080
                m3 := mload(0x60)
    2081
                m4 := mload(0x80)
    2082
                m5 := mload(0xa0)
    2083
                // Selector of `log(uint256,uint256,string)`.
    2084
                mstore(0x00, 0x71d04af2)
    2085
                mstore(0x20, p0)
    2086
                mstore(0x40, p1)
    2087
                mstore(0x60, 0x60)
    2088
                writeString(0x80, p2)
    2089
            }
    2090
            _sendLogPayload(0x1c, 0xa4);
    2091
            /// @solidity memory-safe-assembly
    2092
            assembly {
    2093
                mstore(0x00, m0)
    2094
                mstore(0x20, m1)
    2095
                mstore(0x40, m2)
    2096
                mstore(0x60, m3)
    2097
                mstore(0x80, m4)
    2098
                mstore(0xa0, m5)
    2099
            }
    2100
        }
    2101
    2102
        function log(uint256 p0, bytes32 p1, address p2) internal pure {
    2103
            bytes32 m0;
    2104
            bytes32 m1;
    2105
            bytes32 m2;
    2106
            bytes32 m3;
    2107
            bytes32 m4;
    2108
            bytes32 m5;
    2109
            /// @solidity memory-safe-assembly
    2110
            assembly {
    2111
                function writeString(pos, w) {
    2112
                    let length := 0
    2113
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2114
                    mstore(pos, length)
    2115
                    let shift := sub(256, shl(3, length))
    2116
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2117
                }
    2118
                m0 := mload(0x00)
    2119
                m1 := mload(0x20)
    2120
                m2 := mload(0x40)
    2121
                m3 := mload(0x60)
    2122
                m4 := mload(0x80)
    2123
                m5 := mload(0xa0)
    2124
                // Selector of `log(uint256,string,address)`.
    2125
                mstore(0x00, 0x7afac959)
    2126
                mstore(0x20, p0)
    2127
                mstore(0x40, 0x60)
    2128
                mstore(0x60, p2)
    2129
                writeString(0x80, p1)
    2130
            }
    2131
            _sendLogPayload(0x1c, 0xa4);
    2132
            /// @solidity memory-safe-assembly
    2133
            assembly {
    2134
                mstore(0x00, m0)
    2135
                mstore(0x20, m1)
    2136
                mstore(0x40, m2)
    2137
                mstore(0x60, m3)
    2138
                mstore(0x80, m4)
    2139
                mstore(0xa0, m5)
    2140
            }
    2141
        }
    2142
    2143
        function log(uint256 p0, bytes32 p1, bool p2) internal pure {
    2144
            bytes32 m0;
    2145
            bytes32 m1;
    2146
            bytes32 m2;
    2147
            bytes32 m3;
    2148
            bytes32 m4;
    2149
            bytes32 m5;
    2150
            /// @solidity memory-safe-assembly
    2151
            assembly {
    2152
                function writeString(pos, w) {
    2153
                    let length := 0
    2154
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2155
                    mstore(pos, length)
    2156
                    let shift := sub(256, shl(3, length))
    2157
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2158
                }
    2159
                m0 := mload(0x00)
    2160
                m1 := mload(0x20)
    2161
                m2 := mload(0x40)
    2162
                m3 := mload(0x60)
    2163
                m4 := mload(0x80)
    2164
                m5 := mload(0xa0)
    2165
                // Selector of `log(uint256,string,bool)`.
    2166
                mstore(0x00, 0x4ceda75a)
    2167
                mstore(0x20, p0)
    2168
                mstore(0x40, 0x60)
    2169
                mstore(0x60, p2)
    2170
                writeString(0x80, p1)
    2171
            }
    2172
            _sendLogPayload(0x1c, 0xa4);
    2173
            /// @solidity memory-safe-assembly
    2174
            assembly {
    2175
                mstore(0x00, m0)
    2176
                mstore(0x20, m1)
    2177
                mstore(0x40, m2)
    2178
                mstore(0x60, m3)
    2179
                mstore(0x80, m4)
    2180
                mstore(0xa0, m5)
    2181
            }
    2182
        }
    2183
    2184
        function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {
    2185
            bytes32 m0;
    2186
            bytes32 m1;
    2187
            bytes32 m2;
    2188
            bytes32 m3;
    2189
            bytes32 m4;
    2190
            bytes32 m5;
    2191
            /// @solidity memory-safe-assembly
    2192
            assembly {
    2193
                function writeString(pos, w) {
    2194
                    let length := 0
    2195
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2196
                    mstore(pos, length)
    2197
                    let shift := sub(256, shl(3, length))
    2198
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2199
                }
    2200
                m0 := mload(0x00)
    2201
                m1 := mload(0x20)
    2202
                m2 := mload(0x40)
    2203
                m3 := mload(0x60)
    2204
                m4 := mload(0x80)
    2205
                m5 := mload(0xa0)
    2206
                // Selector of `log(uint256,string,uint256)`.
    2207
                mstore(0x00, 0x37aa7d4c)
    2208
                mstore(0x20, p0)
    2209
                mstore(0x40, 0x60)
    2210
                mstore(0x60, p2)
    2211
                writeString(0x80, p1)
    2212
            }
    2213
            _sendLogPayload(0x1c, 0xa4);
    2214
            /// @solidity memory-safe-assembly
    2215
            assembly {
    2216
                mstore(0x00, m0)
    2217
                mstore(0x20, m1)
    2218
                mstore(0x40, m2)
    2219
                mstore(0x60, m3)
    2220
                mstore(0x80, m4)
    2221
                mstore(0xa0, m5)
    2222
            }
    2223
        }
    2224
    2225
        function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {
    2226
            bytes32 m0;
    2227
            bytes32 m1;
    2228
            bytes32 m2;
    2229
            bytes32 m3;
    2230
            bytes32 m4;
    2231
            bytes32 m5;
    2232
            bytes32 m6;
    2233
            bytes32 m7;
    2234
            /// @solidity memory-safe-assembly
    2235
            assembly {
    2236
                function writeString(pos, w) {
    2237
                    let length := 0
    2238
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2239
                    mstore(pos, length)
    2240
                    let shift := sub(256, shl(3, length))
    2241
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2242
                }
    2243
                m0 := mload(0x00)
    2244
                m1 := mload(0x20)
    2245
                m2 := mload(0x40)
    2246
                m3 := mload(0x60)
    2247
                m4 := mload(0x80)
    2248
                m5 := mload(0xa0)
    2249
                m6 := mload(0xc0)
    2250
                m7 := mload(0xe0)
    2251
                // Selector of `log(uint256,string,string)`.
    2252
                mstore(0x00, 0xb115611f)
    2253
                mstore(0x20, p0)
    2254
                mstore(0x40, 0x60)
    2255
                mstore(0x60, 0xa0)
    2256
                writeString(0x80, p1)
    2257
                writeString(0xc0, p2)
    2258
            }
    2259
            _sendLogPayload(0x1c, 0xe4);
    2260
            /// @solidity memory-safe-assembly
    2261
            assembly {
    2262
                mstore(0x00, m0)
    2263
                mstore(0x20, m1)
    2264
                mstore(0x40, m2)
    2265
                mstore(0x60, m3)
    2266
                mstore(0x80, m4)
    2267
                mstore(0xa0, m5)
    2268
                mstore(0xc0, m6)
    2269
                mstore(0xe0, m7)
    2270
            }
    2271
        }
    2272
    2273
        function log(bytes32 p0, address p1, address p2) internal pure {
    2274
            bytes32 m0;
    2275
            bytes32 m1;
    2276
            bytes32 m2;
    2277
            bytes32 m3;
    2278
            bytes32 m4;
    2279
            bytes32 m5;
    2280
            /// @solidity memory-safe-assembly
    2281
            assembly {
    2282
                function writeString(pos, w) {
    2283
                    let length := 0
    2284
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2285
                    mstore(pos, length)
    2286
                    let shift := sub(256, shl(3, length))
    2287
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2288
                }
    2289
                m0 := mload(0x00)
    2290
                m1 := mload(0x20)
    2291
                m2 := mload(0x40)
    2292
                m3 := mload(0x60)
    2293
                m4 := mload(0x80)
    2294
                m5 := mload(0xa0)
    2295
                // Selector of `log(string,address,address)`.
    2296
                mstore(0x00, 0xfcec75e0)
    2297
                mstore(0x20, 0x60)
    2298
                mstore(0x40, p1)
    2299
                mstore(0x60, p2)
    2300
                writeString(0x80, p0)
    2301
            }
    2302
            _sendLogPayload(0x1c, 0xa4);
    2303
            /// @solidity memory-safe-assembly
    2304
            assembly {
    2305
                mstore(0x00, m0)
    2306
                mstore(0x20, m1)
    2307
                mstore(0x40, m2)
    2308
                mstore(0x60, m3)
    2309
                mstore(0x80, m4)
    2310
                mstore(0xa0, m5)
    2311
            }
    2312
        }
    2313
    2314
        function log(bytes32 p0, address p1, bool p2) internal pure {
    2315
            bytes32 m0;
    2316
            bytes32 m1;
    2317
            bytes32 m2;
    2318
            bytes32 m3;
    2319
            bytes32 m4;
    2320
            bytes32 m5;
    2321
            /// @solidity memory-safe-assembly
    2322
            assembly {
    2323
                function writeString(pos, w) {
    2324
                    let length := 0
    2325
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2326
                    mstore(pos, length)
    2327
                    let shift := sub(256, shl(3, length))
    2328
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2329
                }
    2330
                m0 := mload(0x00)
    2331
                m1 := mload(0x20)
    2332
                m2 := mload(0x40)
    2333
                m3 := mload(0x60)
    2334
                m4 := mload(0x80)
    2335
                m5 := mload(0xa0)
    2336
                // Selector of `log(string,address,bool)`.
    2337
                mstore(0x00, 0xc91d5ed4)
    2338
                mstore(0x20, 0x60)
    2339
                mstore(0x40, p1)
    2340
                mstore(0x60, p2)
    2341
                writeString(0x80, p0)
    2342
            }
    2343
            _sendLogPayload(0x1c, 0xa4);
    2344
            /// @solidity memory-safe-assembly
    2345
            assembly {
    2346
                mstore(0x00, m0)
    2347
                mstore(0x20, m1)
    2348
                mstore(0x40, m2)
    2349
                mstore(0x60, m3)
    2350
                mstore(0x80, m4)
    2351
                mstore(0xa0, m5)
    2352
            }
    2353
        }
    2354
    2355
        function log(bytes32 p0, address p1, uint256 p2) internal pure {
    2356
            bytes32 m0;
    2357
            bytes32 m1;
    2358
            bytes32 m2;
    2359
            bytes32 m3;
    2360
            bytes32 m4;
    2361
            bytes32 m5;
    2362
            /// @solidity memory-safe-assembly
    2363
            assembly {
    2364
                function writeString(pos, w) {
    2365
                    let length := 0
    2366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2367
                    mstore(pos, length)
    2368
                    let shift := sub(256, shl(3, length))
    2369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2370
                }
    2371
                m0 := mload(0x00)
    2372
                m1 := mload(0x20)
    2373
                m2 := mload(0x40)
    2374
                m3 := mload(0x60)
    2375
                m4 := mload(0x80)
    2376
                m5 := mload(0xa0)
    2377
                // Selector of `log(string,address,uint256)`.
    2378
                mstore(0x00, 0x0d26b925)
    2379
                mstore(0x20, 0x60)
    2380
                mstore(0x40, p1)
    2381
                mstore(0x60, p2)
    2382
                writeString(0x80, p0)
    2383
            }
    2384
            _sendLogPayload(0x1c, 0xa4);
    2385
            /// @solidity memory-safe-assembly
    2386
            assembly {
    2387
                mstore(0x00, m0)
    2388
                mstore(0x20, m1)
    2389
                mstore(0x40, m2)
    2390
                mstore(0x60, m3)
    2391
                mstore(0x80, m4)
    2392
                mstore(0xa0, m5)
    2393
            }
    2394
        }
    2395
    2396
        function log(bytes32 p0, address p1, bytes32 p2) internal pure {
    2397
            bytes32 m0;
    2398
            bytes32 m1;
    2399
            bytes32 m2;
    2400
            bytes32 m3;
    2401
            bytes32 m4;
    2402
            bytes32 m5;
    2403
            bytes32 m6;
    2404
            bytes32 m7;
    2405
            /// @solidity memory-safe-assembly
    2406
            assembly {
    2407
                function writeString(pos, w) {
    2408
                    let length := 0
    2409
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2410
                    mstore(pos, length)
    2411
                    let shift := sub(256, shl(3, length))
    2412
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2413
                }
    2414
                m0 := mload(0x00)
    2415
                m1 := mload(0x20)
    2416
                m2 := mload(0x40)
    2417
                m3 := mload(0x60)
    2418
                m4 := mload(0x80)
    2419
                m5 := mload(0xa0)
    2420
                m6 := mload(0xc0)
    2421
                m7 := mload(0xe0)
    2422
                // Selector of `log(string,address,string)`.
    2423
                mstore(0x00, 0xe0e9ad4f)
    2424
                mstore(0x20, 0x60)
    2425
                mstore(0x40, p1)
    2426
                mstore(0x60, 0xa0)
    2427
                writeString(0x80, p0)
    2428
                writeString(0xc0, p2)
    2429
            }
    2430
            _sendLogPayload(0x1c, 0xe4);
    2431
            /// @solidity memory-safe-assembly
    2432
            assembly {
    2433
                mstore(0x00, m0)
    2434
                mstore(0x20, m1)
    2435
                mstore(0x40, m2)
    2436
                mstore(0x60, m3)
    2437
                mstore(0x80, m4)
    2438
                mstore(0xa0, m5)
    2439
                mstore(0xc0, m6)
    2440
                mstore(0xe0, m7)
    2441
            }
    2442
        }
    2443
    2444
        function log(bytes32 p0, bool p1, address p2) internal pure {
    2445
            bytes32 m0;
    2446
            bytes32 m1;
    2447
            bytes32 m2;
    2448
            bytes32 m3;
    2449
            bytes32 m4;
    2450
            bytes32 m5;
    2451
            /// @solidity memory-safe-assembly
    2452
            assembly {
    2453
                function writeString(pos, w) {
    2454
                    let length := 0
    2455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2456
                    mstore(pos, length)
    2457
                    let shift := sub(256, shl(3, length))
    2458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2459
                }
    2460
                m0 := mload(0x00)
    2461
                m1 := mload(0x20)
    2462
                m2 := mload(0x40)
    2463
                m3 := mload(0x60)
    2464
                m4 := mload(0x80)
    2465
                m5 := mload(0xa0)
    2466
                // Selector of `log(string,bool,address)`.
    2467
                mstore(0x00, 0x932bbb38)
    2468
                mstore(0x20, 0x60)
    2469
                mstore(0x40, p1)
    2470
                mstore(0x60, p2)
    2471
                writeString(0x80, p0)
    2472
            }
    2473
            _sendLogPayload(0x1c, 0xa4);
    2474
            /// @solidity memory-safe-assembly
    2475
            assembly {
    2476
                mstore(0x00, m0)
    2477
                mstore(0x20, m1)
    2478
                mstore(0x40, m2)
    2479
                mstore(0x60, m3)
    2480
                mstore(0x80, m4)
    2481
                mstore(0xa0, m5)
    2482
            }
    2483
        }
    2484
    2485
        function log(bytes32 p0, bool p1, bool p2) internal pure {
    2486
            bytes32 m0;
    2487
            bytes32 m1;
    2488
            bytes32 m2;
    2489
            bytes32 m3;
    2490
            bytes32 m4;
    2491
            bytes32 m5;
    2492
            /// @solidity memory-safe-assembly
    2493
            assembly {
    2494
                function writeString(pos, w) {
    2495
                    let length := 0
    2496
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2497
                    mstore(pos, length)
    2498
                    let shift := sub(256, shl(3, length))
    2499
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2500
                }
    2501
                m0 := mload(0x00)
    2502
                m1 := mload(0x20)
    2503
                m2 := mload(0x40)
    2504
                m3 := mload(0x60)
    2505
                m4 := mload(0x80)
    2506
                m5 := mload(0xa0)
    2507
                // Selector of `log(string,bool,bool)`.
    2508
                mstore(0x00, 0x850b7ad6)
    2509
                mstore(0x20, 0x60)
    2510
                mstore(0x40, p1)
    2511
                mstore(0x60, p2)
    2512
                writeString(0x80, p0)
    2513
            }
    2514
            _sendLogPayload(0x1c, 0xa4);
    2515
            /// @solidity memory-safe-assembly
    2516
            assembly {
    2517
                mstore(0x00, m0)
    2518
                mstore(0x20, m1)
    2519
                mstore(0x40, m2)
    2520
                mstore(0x60, m3)
    2521
                mstore(0x80, m4)
    2522
                mstore(0xa0, m5)
    2523
            }
    2524
        }
    2525
    2526
        function log(bytes32 p0, bool p1, uint256 p2) internal pure {
    2527
            bytes32 m0;
    2528
            bytes32 m1;
    2529
            bytes32 m2;
    2530
            bytes32 m3;
    2531
            bytes32 m4;
    2532
            bytes32 m5;
    2533
            /// @solidity memory-safe-assembly
    2534
            assembly {
    2535
                function writeString(pos, w) {
    2536
                    let length := 0
    2537
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2538
                    mstore(pos, length)
    2539
                    let shift := sub(256, shl(3, length))
    2540
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2541
                }
    2542
                m0 := mload(0x00)
    2543
                m1 := mload(0x20)
    2544
                m2 := mload(0x40)
    2545
                m3 := mload(0x60)
    2546
                m4 := mload(0x80)
    2547
                m5 := mload(0xa0)
    2548
                // Selector of `log(string,bool,uint256)`.
    2549
                mstore(0x00, 0xc95958d6)
    2550
                mstore(0x20, 0x60)
    2551
                mstore(0x40, p1)
    2552
                mstore(0x60, p2)
    2553
                writeString(0x80, p0)
    2554
            }
    2555
            _sendLogPayload(0x1c, 0xa4);
    2556
            /// @solidity memory-safe-assembly
    2557
            assembly {
    2558
                mstore(0x00, m0)
    2559
                mstore(0x20, m1)
    2560
                mstore(0x40, m2)
    2561
                mstore(0x60, m3)
    2562
                mstore(0x80, m4)
    2563
                mstore(0xa0, m5)
    2564
            }
    2565
        }
    2566
    2567
        function log(bytes32 p0, bool p1, bytes32 p2) internal pure {
    2568
            bytes32 m0;
    2569
            bytes32 m1;
    2570
            bytes32 m2;
    2571
            bytes32 m3;
    2572
            bytes32 m4;
    2573
            bytes32 m5;
    2574
            bytes32 m6;
    2575
            bytes32 m7;
    2576
            /// @solidity memory-safe-assembly
    2577
            assembly {
    2578
                function writeString(pos, w) {
    2579
                    let length := 0
    2580
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2581
                    mstore(pos, length)
    2582
                    let shift := sub(256, shl(3, length))
    2583
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2584
                }
    2585
                m0 := mload(0x00)
    2586
                m1 := mload(0x20)
    2587
                m2 := mload(0x40)
    2588
                m3 := mload(0x60)
    2589
                m4 := mload(0x80)
    2590
                m5 := mload(0xa0)
    2591
                m6 := mload(0xc0)
    2592
                m7 := mload(0xe0)
    2593
                // Selector of `log(string,bool,string)`.
    2594
                mstore(0x00, 0xe298f47d)
    2595
                mstore(0x20, 0x60)
    2596
                mstore(0x40, p1)
    2597
                mstore(0x60, 0xa0)
    2598
                writeString(0x80, p0)
    2599
                writeString(0xc0, p2)
    2600
            }
    2601
            _sendLogPayload(0x1c, 0xe4);
    2602
            /// @solidity memory-safe-assembly
    2603
            assembly {
    2604
                mstore(0x00, m0)
    2605
                mstore(0x20, m1)
    2606
                mstore(0x40, m2)
    2607
                mstore(0x60, m3)
    2608
                mstore(0x80, m4)
    2609
                mstore(0xa0, m5)
    2610
                mstore(0xc0, m6)
    2611
                mstore(0xe0, m7)
    2612
            }
    2613
        }
    2614
    2615
        function log(bytes32 p0, uint256 p1, address p2) internal pure {
    2616
            bytes32 m0;
    2617
            bytes32 m1;
    2618
            bytes32 m2;
    2619
            bytes32 m3;
    2620
            bytes32 m4;
    2621
            bytes32 m5;
    2622
            /// @solidity memory-safe-assembly
    2623
            assembly {
    2624
                function writeString(pos, w) {
    2625
                    let length := 0
    2626
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2627
                    mstore(pos, length)
    2628
                    let shift := sub(256, shl(3, length))
    2629
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2630
                }
    2631
                m0 := mload(0x00)
    2632
                m1 := mload(0x20)
    2633
                m2 := mload(0x40)
    2634
                m3 := mload(0x60)
    2635
                m4 := mload(0x80)
    2636
                m5 := mload(0xa0)
    2637
                // Selector of `log(string,uint256,address)`.
    2638
                mstore(0x00, 0x1c7ec448)
    2639
                mstore(0x20, 0x60)
    2640
                mstore(0x40, p1)
    2641
                mstore(0x60, p2)
    2642
                writeString(0x80, p0)
    2643
            }
    2644
            _sendLogPayload(0x1c, 0xa4);
    2645
            /// @solidity memory-safe-assembly
    2646
            assembly {
    2647
                mstore(0x00, m0)
    2648
                mstore(0x20, m1)
    2649
                mstore(0x40, m2)
    2650
                mstore(0x60, m3)
    2651
                mstore(0x80, m4)
    2652
                mstore(0xa0, m5)
    2653
            }
    2654
        }
    2655
    2656
        function log(bytes32 p0, uint256 p1, bool p2) internal pure {
    2657
            bytes32 m0;
    2658
            bytes32 m1;
    2659
            bytes32 m2;
    2660
            bytes32 m3;
    2661
            bytes32 m4;
    2662
            bytes32 m5;
    2663
            /// @solidity memory-safe-assembly
    2664
            assembly {
    2665
                function writeString(pos, w) {
    2666
                    let length := 0
    2667
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2668
                    mstore(pos, length)
    2669
                    let shift := sub(256, shl(3, length))
    2670
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2671
                }
    2672
                m0 := mload(0x00)
    2673
                m1 := mload(0x20)
    2674
                m2 := mload(0x40)
    2675
                m3 := mload(0x60)
    2676
                m4 := mload(0x80)
    2677
                m5 := mload(0xa0)
    2678
                // Selector of `log(string,uint256,bool)`.
    2679
                mstore(0x00, 0xca7733b1)
    2680
                mstore(0x20, 0x60)
    2681
                mstore(0x40, p1)
    2682
                mstore(0x60, p2)
    2683
                writeString(0x80, p0)
    2684
            }
    2685
            _sendLogPayload(0x1c, 0xa4);
    2686
            /// @solidity memory-safe-assembly
    2687
            assembly {
    2688
                mstore(0x00, m0)
    2689
                mstore(0x20, m1)
    2690
                mstore(0x40, m2)
    2691
                mstore(0x60, m3)
    2692
                mstore(0x80, m4)
    2693
                mstore(0xa0, m5)
    2694
            }
    2695
        }
    2696
    2697
        function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {
    2698
            bytes32 m0;
    2699
            bytes32 m1;
    2700
            bytes32 m2;
    2701
            bytes32 m3;
    2702
            bytes32 m4;
    2703
            bytes32 m5;
    2704
            /// @solidity memory-safe-assembly
    2705
            assembly {
    2706
                function writeString(pos, w) {
    2707
                    let length := 0
    2708
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2709
                    mstore(pos, length)
    2710
                    let shift := sub(256, shl(3, length))
    2711
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2712
                }
    2713
                m0 := mload(0x00)
    2714
                m1 := mload(0x20)
    2715
                m2 := mload(0x40)
    2716
                m3 := mload(0x60)
    2717
                m4 := mload(0x80)
    2718
                m5 := mload(0xa0)
    2719
                // Selector of `log(string,uint256,uint256)`.
    2720
                mstore(0x00, 0xca47c4eb)
    2721
                mstore(0x20, 0x60)
    2722
                mstore(0x40, p1)
    2723
                mstore(0x60, p2)
    2724
                writeString(0x80, p0)
    2725
            }
    2726
            _sendLogPayload(0x1c, 0xa4);
    2727
            /// @solidity memory-safe-assembly
    2728
            assembly {
    2729
                mstore(0x00, m0)
    2730
                mstore(0x20, m1)
    2731
                mstore(0x40, m2)
    2732
                mstore(0x60, m3)
    2733
                mstore(0x80, m4)
    2734
                mstore(0xa0, m5)
    2735
            }
    2736
        }
    2737
    2738
        function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {
    2739
            bytes32 m0;
    2740
            bytes32 m1;
    2741
            bytes32 m2;
    2742
            bytes32 m3;
    2743
            bytes32 m4;
    2744
            bytes32 m5;
    2745
            bytes32 m6;
    2746
            bytes32 m7;
    2747
            /// @solidity memory-safe-assembly
    2748
            assembly {
    2749
                function writeString(pos, w) {
    2750
                    let length := 0
    2751
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2752
                    mstore(pos, length)
    2753
                    let shift := sub(256, shl(3, length))
    2754
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2755
                }
    2756
                m0 := mload(0x00)
    2757
                m1 := mload(0x20)
    2758
                m2 := mload(0x40)
    2759
                m3 := mload(0x60)
    2760
                m4 := mload(0x80)
    2761
                m5 := mload(0xa0)
    2762
                m6 := mload(0xc0)
    2763
                m7 := mload(0xe0)
    2764
                // Selector of `log(string,uint256,string)`.
    2765
                mstore(0x00, 0x5970e089)
    2766
                mstore(0x20, 0x60)
    2767
                mstore(0x40, p1)
    2768
                mstore(0x60, 0xa0)
    2769
                writeString(0x80, p0)
    2770
                writeString(0xc0, p2)
    2771
            }
    2772
            _sendLogPayload(0x1c, 0xe4);
    2773
            /// @solidity memory-safe-assembly
    2774
            assembly {
    2775
                mstore(0x00, m0)
    2776
                mstore(0x20, m1)
    2777
                mstore(0x40, m2)
    2778
                mstore(0x60, m3)
    2779
                mstore(0x80, m4)
    2780
                mstore(0xa0, m5)
    2781
                mstore(0xc0, m6)
    2782
                mstore(0xe0, m7)
    2783
            }
    2784
        }
    2785
    2786
        function log(bytes32 p0, bytes32 p1, address p2) internal pure {
    2787
            bytes32 m0;
    2788
            bytes32 m1;
    2789
            bytes32 m2;
    2790
            bytes32 m3;
    2791
            bytes32 m4;
    2792
            bytes32 m5;
    2793
            bytes32 m6;
    2794
            bytes32 m7;
    2795
            /// @solidity memory-safe-assembly
    2796
            assembly {
    2797
                function writeString(pos, w) {
    2798
                    let length := 0
    2799
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2800
                    mstore(pos, length)
    2801
                    let shift := sub(256, shl(3, length))
    2802
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2803
                }
    2804
                m0 := mload(0x00)
    2805
                m1 := mload(0x20)
    2806
                m2 := mload(0x40)
    2807
                m3 := mload(0x60)
    2808
                m4 := mload(0x80)
    2809
                m5 := mload(0xa0)
    2810
                m6 := mload(0xc0)
    2811
                m7 := mload(0xe0)
    2812
                // Selector of `log(string,string,address)`.
    2813
                mstore(0x00, 0x95ed0195)
    2814
                mstore(0x20, 0x60)
    2815
                mstore(0x40, 0xa0)
    2816
                mstore(0x60, p2)
    2817
                writeString(0x80, p0)
    2818
                writeString(0xc0, p1)
    2819
            }
    2820
            _sendLogPayload(0x1c, 0xe4);
    2821
            /// @solidity memory-safe-assembly
    2822
            assembly {
    2823
                mstore(0x00, m0)
    2824
                mstore(0x20, m1)
    2825
                mstore(0x40, m2)
    2826
                mstore(0x60, m3)
    2827
                mstore(0x80, m4)
    2828
                mstore(0xa0, m5)
    2829
                mstore(0xc0, m6)
    2830
                mstore(0xe0, m7)
    2831
            }
    2832
        }
    2833
    2834
        function log(bytes32 p0, bytes32 p1, bool p2) internal pure {
    2835
            bytes32 m0;
    2836
            bytes32 m1;
    2837
            bytes32 m2;
    2838
            bytes32 m3;
    2839
            bytes32 m4;
    2840
            bytes32 m5;
    2841
            bytes32 m6;
    2842
            bytes32 m7;
    2843
            /// @solidity memory-safe-assembly
    2844
            assembly {
    2845
                function writeString(pos, w) {
    2846
                    let length := 0
    2847
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2848
                    mstore(pos, length)
    2849
                    let shift := sub(256, shl(3, length))
    2850
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2851
                }
    2852
                m0 := mload(0x00)
    2853
                m1 := mload(0x20)
    2854
                m2 := mload(0x40)
    2855
                m3 := mload(0x60)
    2856
                m4 := mload(0x80)
    2857
                m5 := mload(0xa0)
    2858
                m6 := mload(0xc0)
    2859
                m7 := mload(0xe0)
    2860
                // Selector of `log(string,string,bool)`.
    2861
                mstore(0x00, 0xb0e0f9b5)
    2862
                mstore(0x20, 0x60)
    2863
                mstore(0x40, 0xa0)
    2864
                mstore(0x60, p2)
    2865
                writeString(0x80, p0)
    2866
                writeString(0xc0, p1)
    2867
            }
    2868
            _sendLogPayload(0x1c, 0xe4);
    2869
            /// @solidity memory-safe-assembly
    2870
            assembly {
    2871
                mstore(0x00, m0)
    2872
                mstore(0x20, m1)
    2873
                mstore(0x40, m2)
    2874
                mstore(0x60, m3)
    2875
                mstore(0x80, m4)
    2876
                mstore(0xa0, m5)
    2877
                mstore(0xc0, m6)
    2878
                mstore(0xe0, m7)
    2879
            }
    2880
        }
    2881
    2882
        function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {
    2883
            bytes32 m0;
    2884
            bytes32 m1;
    2885
            bytes32 m2;
    2886
            bytes32 m3;
    2887
            bytes32 m4;
    2888
            bytes32 m5;
    2889
            bytes32 m6;
    2890
            bytes32 m7;
    2891
            /// @solidity memory-safe-assembly
    2892
            assembly {
    2893
                function writeString(pos, w) {
    2894
                    let length := 0
    2895
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2896
                    mstore(pos, length)
    2897
                    let shift := sub(256, shl(3, length))
    2898
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2899
                }
    2900
                m0 := mload(0x00)
    2901
                m1 := mload(0x20)
    2902
                m2 := mload(0x40)
    2903
                m3 := mload(0x60)
    2904
                m4 := mload(0x80)
    2905
                m5 := mload(0xa0)
    2906
                m6 := mload(0xc0)
    2907
                m7 := mload(0xe0)
    2908
                // Selector of `log(string,string,uint256)`.
    2909
                mstore(0x00, 0x5821efa1)
    2910
                mstore(0x20, 0x60)
    2911
                mstore(0x40, 0xa0)
    2912
                mstore(0x60, p2)
    2913
                writeString(0x80, p0)
    2914
                writeString(0xc0, p1)
    2915
            }
    2916
            _sendLogPayload(0x1c, 0xe4);
    2917
            /// @solidity memory-safe-assembly
    2918
            assembly {
    2919
                mstore(0x00, m0)
    2920
                mstore(0x20, m1)
    2921
                mstore(0x40, m2)
    2922
                mstore(0x60, m3)
    2923
                mstore(0x80, m4)
    2924
                mstore(0xa0, m5)
    2925
                mstore(0xc0, m6)
    2926
                mstore(0xe0, m7)
    2927
            }
    2928
        }
    2929
    2930
        function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {
    2931
            bytes32 m0;
    2932
            bytes32 m1;
    2933
            bytes32 m2;
    2934
            bytes32 m3;
    2935
            bytes32 m4;
    2936
            bytes32 m5;
    2937
            bytes32 m6;
    2938
            bytes32 m7;
    2939
            bytes32 m8;
    2940
            bytes32 m9;
    2941
            /// @solidity memory-safe-assembly
    2942
            assembly {
    2943
                function writeString(pos, w) {
    2944
                    let length := 0
    2945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    2946
                    mstore(pos, length)
    2947
                    let shift := sub(256, shl(3, length))
    2948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    2949
                }
    2950
                m0 := mload(0x00)
    2951
                m1 := mload(0x20)
    2952
                m2 := mload(0x40)
    2953
                m3 := mload(0x60)
    2954
                m4 := mload(0x80)
    2955
                m5 := mload(0xa0)
    2956
                m6 := mload(0xc0)
    2957
                m7 := mload(0xe0)
    2958
                m8 := mload(0x100)
    2959
                m9 := mload(0x120)
    2960
                // Selector of `log(string,string,string)`.
    2961
                mstore(0x00, 0x2ced7cef)
    2962
                mstore(0x20, 0x60)
    2963
                mstore(0x40, 0xa0)
    2964
                mstore(0x60, 0xe0)
    2965
                writeString(0x80, p0)
    2966
                writeString(0xc0, p1)
    2967
                writeString(0x100, p2)
    2968
            }
    2969
            _sendLogPayload(0x1c, 0x124);
    2970
            /// @solidity memory-safe-assembly
    2971
            assembly {
    2972
                mstore(0x00, m0)
    2973
                mstore(0x20, m1)
    2974
                mstore(0x40, m2)
    2975
                mstore(0x60, m3)
    2976
                mstore(0x80, m4)
    2977
                mstore(0xa0, m5)
    2978
                mstore(0xc0, m6)
    2979
                mstore(0xe0, m7)
    2980
                mstore(0x100, m8)
    2981
                mstore(0x120, m9)
    2982
            }
    2983
        }
    2984
    2985
        function log(address p0, address p1, address p2, address p3) internal pure {
    2986
            bytes32 m0;
    2987
            bytes32 m1;
    2988
            bytes32 m2;
    2989
            bytes32 m3;
    2990
            bytes32 m4;
    2991
            /// @solidity memory-safe-assembly
    2992
            assembly {
    2993
                m0 := mload(0x00)
    2994
                m1 := mload(0x20)
    2995
                m2 := mload(0x40)
    2996
                m3 := mload(0x60)
    2997
                m4 := mload(0x80)
    2998
                // Selector of `log(address,address,address,address)`.
    2999
                mstore(0x00, 0x665bf134)
    3000
                mstore(0x20, p0)
    3001
                mstore(0x40, p1)
    3002
                mstore(0x60, p2)
    3003
                mstore(0x80, p3)
    3004
            }
    3005
            _sendLogPayload(0x1c, 0x84);
    3006
            /// @solidity memory-safe-assembly
    3007
            assembly {
    3008
                mstore(0x00, m0)
    3009
                mstore(0x20, m1)
    3010
                mstore(0x40, m2)
    3011
                mstore(0x60, m3)
    3012
                mstore(0x80, m4)
    3013
            }
    3014
        }
    3015
    3016
        function log(address p0, address p1, address p2, bool p3) internal pure {
    3017
            bytes32 m0;
    3018
            bytes32 m1;
    3019
            bytes32 m2;
    3020
            bytes32 m3;
    3021
            bytes32 m4;
    3022
            /// @solidity memory-safe-assembly
    3023
            assembly {
    3024
                m0 := mload(0x00)
    3025
                m1 := mload(0x20)
    3026
                m2 := mload(0x40)
    3027
                m3 := mload(0x60)
    3028
                m4 := mload(0x80)
    3029
                // Selector of `log(address,address,address,bool)`.
    3030
                mstore(0x00, 0x0e378994)
    3031
                mstore(0x20, p0)
    3032
                mstore(0x40, p1)
    3033
                mstore(0x60, p2)
    3034
                mstore(0x80, p3)
    3035
            }
    3036
            _sendLogPayload(0x1c, 0x84);
    3037
            /// @solidity memory-safe-assembly
    3038
            assembly {
    3039
                mstore(0x00, m0)
    3040
                mstore(0x20, m1)
    3041
                mstore(0x40, m2)
    3042
                mstore(0x60, m3)
    3043
                mstore(0x80, m4)
    3044
            }
    3045
        }
    3046
    3047
        function log(address p0, address p1, address p2, uint256 p3) internal pure {
    3048
            bytes32 m0;
    3049
            bytes32 m1;
    3050
            bytes32 m2;
    3051
            bytes32 m3;
    3052
            bytes32 m4;
    3053
            /// @solidity memory-safe-assembly
    3054
            assembly {
    3055
                m0 := mload(0x00)
    3056
                m1 := mload(0x20)
    3057
                m2 := mload(0x40)
    3058
                m3 := mload(0x60)
    3059
                m4 := mload(0x80)
    3060
                // Selector of `log(address,address,address,uint256)`.
    3061
                mstore(0x00, 0x94250d77)
    3062
                mstore(0x20, p0)
    3063
                mstore(0x40, p1)
    3064
                mstore(0x60, p2)
    3065
                mstore(0x80, p3)
    3066
            }
    3067
            _sendLogPayload(0x1c, 0x84);
    3068
            /// @solidity memory-safe-assembly
    3069
            assembly {
    3070
                mstore(0x00, m0)
    3071
                mstore(0x20, m1)
    3072
                mstore(0x40, m2)
    3073
                mstore(0x60, m3)
    3074
                mstore(0x80, m4)
    3075
            }
    3076
        }
    3077
    3078
        function log(address p0, address p1, address p2, bytes32 p3) internal pure {
    3079
            bytes32 m0;
    3080
            bytes32 m1;
    3081
            bytes32 m2;
    3082
            bytes32 m3;
    3083
            bytes32 m4;
    3084
            bytes32 m5;
    3085
            bytes32 m6;
    3086
            /// @solidity memory-safe-assembly
    3087
            assembly {
    3088
                function writeString(pos, w) {
    3089
                    let length := 0
    3090
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3091
                    mstore(pos, length)
    3092
                    let shift := sub(256, shl(3, length))
    3093
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3094
                }
    3095
                m0 := mload(0x00)
    3096
                m1 := mload(0x20)
    3097
                m2 := mload(0x40)
    3098
                m3 := mload(0x60)
    3099
                m4 := mload(0x80)
    3100
                m5 := mload(0xa0)
    3101
                m6 := mload(0xc0)
    3102
                // Selector of `log(address,address,address,string)`.
    3103
                mstore(0x00, 0xf808da20)
    3104
                mstore(0x20, p0)
    3105
                mstore(0x40, p1)
    3106
                mstore(0x60, p2)
    3107
                mstore(0x80, 0x80)
    3108
                writeString(0xa0, p3)
    3109
            }
    3110
            _sendLogPayload(0x1c, 0xc4);
    3111
            /// @solidity memory-safe-assembly
    3112
            assembly {
    3113
                mstore(0x00, m0)
    3114
                mstore(0x20, m1)
    3115
                mstore(0x40, m2)
    3116
                mstore(0x60, m3)
    3117
                mstore(0x80, m4)
    3118
                mstore(0xa0, m5)
    3119
                mstore(0xc0, m6)
    3120
            }
    3121
        }
    3122
    3123
        function log(address p0, address p1, bool p2, address p3) internal pure {
    3124
            bytes32 m0;
    3125
            bytes32 m1;
    3126
            bytes32 m2;
    3127
            bytes32 m3;
    3128
            bytes32 m4;
    3129
            /// @solidity memory-safe-assembly
    3130
            assembly {
    3131
                m0 := mload(0x00)
    3132
                m1 := mload(0x20)
    3133
                m2 := mload(0x40)
    3134
                m3 := mload(0x60)
    3135
                m4 := mload(0x80)
    3136
                // Selector of `log(address,address,bool,address)`.
    3137
                mstore(0x00, 0x9f1bc36e)
    3138
                mstore(0x20, p0)
    3139
                mstore(0x40, p1)
    3140
                mstore(0x60, p2)
    3141
                mstore(0x80, p3)
    3142
            }
    3143
            _sendLogPayload(0x1c, 0x84);
    3144
            /// @solidity memory-safe-assembly
    3145
            assembly {
    3146
                mstore(0x00, m0)
    3147
                mstore(0x20, m1)
    3148
                mstore(0x40, m2)
    3149
                mstore(0x60, m3)
    3150
                mstore(0x80, m4)
    3151
            }
    3152
        }
    3153
    3154
        function log(address p0, address p1, bool p2, bool p3) internal pure {
    3155
            bytes32 m0;
    3156
            bytes32 m1;
    3157
            bytes32 m2;
    3158
            bytes32 m3;
    3159
            bytes32 m4;
    3160
            /// @solidity memory-safe-assembly
    3161
            assembly {
    3162
                m0 := mload(0x00)
    3163
                m1 := mload(0x20)
    3164
                m2 := mload(0x40)
    3165
                m3 := mload(0x60)
    3166
                m4 := mload(0x80)
    3167
                // Selector of `log(address,address,bool,bool)`.
    3168
                mstore(0x00, 0x2cd4134a)
    3169
                mstore(0x20, p0)
    3170
                mstore(0x40, p1)
    3171
                mstore(0x60, p2)
    3172
                mstore(0x80, p3)
    3173
            }
    3174
            _sendLogPayload(0x1c, 0x84);
    3175
            /// @solidity memory-safe-assembly
    3176
            assembly {
    3177
                mstore(0x00, m0)
    3178
                mstore(0x20, m1)
    3179
                mstore(0x40, m2)
    3180
                mstore(0x60, m3)
    3181
                mstore(0x80, m4)
    3182
            }
    3183
        }
    3184
    3185
        function log(address p0, address p1, bool p2, uint256 p3) internal pure {
    3186
            bytes32 m0;
    3187
            bytes32 m1;
    3188
            bytes32 m2;
    3189
            bytes32 m3;
    3190
            bytes32 m4;
    3191
            /// @solidity memory-safe-assembly
    3192
            assembly {
    3193
                m0 := mload(0x00)
    3194
                m1 := mload(0x20)
    3195
                m2 := mload(0x40)
    3196
                m3 := mload(0x60)
    3197
                m4 := mload(0x80)
    3198
                // Selector of `log(address,address,bool,uint256)`.
    3199
                mstore(0x00, 0x3971e78c)
    3200
                mstore(0x20, p0)
    3201
                mstore(0x40, p1)
    3202
                mstore(0x60, p2)
    3203
                mstore(0x80, p3)
    3204
            }
    3205
            _sendLogPayload(0x1c, 0x84);
    3206
            /// @solidity memory-safe-assembly
    3207
            assembly {
    3208
                mstore(0x00, m0)
    3209
                mstore(0x20, m1)
    3210
                mstore(0x40, m2)
    3211
                mstore(0x60, m3)
    3212
                mstore(0x80, m4)
    3213
            }
    3214
        }
    3215
    3216
        function log(address p0, address p1, bool p2, bytes32 p3) internal pure {
    3217
            bytes32 m0;
    3218
            bytes32 m1;
    3219
            bytes32 m2;
    3220
            bytes32 m3;
    3221
            bytes32 m4;
    3222
            bytes32 m5;
    3223
            bytes32 m6;
    3224
            /// @solidity memory-safe-assembly
    3225
            assembly {
    3226
                function writeString(pos, w) {
    3227
                    let length := 0
    3228
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3229
                    mstore(pos, length)
    3230
                    let shift := sub(256, shl(3, length))
    3231
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3232
                }
    3233
                m0 := mload(0x00)
    3234
                m1 := mload(0x20)
    3235
                m2 := mload(0x40)
    3236
                m3 := mload(0x60)
    3237
                m4 := mload(0x80)
    3238
                m5 := mload(0xa0)
    3239
                m6 := mload(0xc0)
    3240
                // Selector of `log(address,address,bool,string)`.
    3241
                mstore(0x00, 0xaa6540c8)
    3242
                mstore(0x20, p0)
    3243
                mstore(0x40, p1)
    3244
                mstore(0x60, p2)
    3245
                mstore(0x80, 0x80)
    3246
                writeString(0xa0, p3)
    3247
            }
    3248
            _sendLogPayload(0x1c, 0xc4);
    3249
            /// @solidity memory-safe-assembly
    3250
            assembly {
    3251
                mstore(0x00, m0)
    3252
                mstore(0x20, m1)
    3253
                mstore(0x40, m2)
    3254
                mstore(0x60, m3)
    3255
                mstore(0x80, m4)
    3256
                mstore(0xa0, m5)
    3257
                mstore(0xc0, m6)
    3258
            }
    3259
        }
    3260
    3261
        function log(address p0, address p1, uint256 p2, address p3) internal pure {
    3262
            bytes32 m0;
    3263
            bytes32 m1;
    3264
            bytes32 m2;
    3265
            bytes32 m3;
    3266
            bytes32 m4;
    3267
            /// @solidity memory-safe-assembly
    3268
            assembly {
    3269
                m0 := mload(0x00)
    3270
                m1 := mload(0x20)
    3271
                m2 := mload(0x40)
    3272
                m3 := mload(0x60)
    3273
                m4 := mload(0x80)
    3274
                // Selector of `log(address,address,uint256,address)`.
    3275
                mstore(0x00, 0x8da6def5)
    3276
                mstore(0x20, p0)
    3277
                mstore(0x40, p1)
    3278
                mstore(0x60, p2)
    3279
                mstore(0x80, p3)
    3280
            }
    3281
            _sendLogPayload(0x1c, 0x84);
    3282
            /// @solidity memory-safe-assembly
    3283
            assembly {
    3284
                mstore(0x00, m0)
    3285
                mstore(0x20, m1)
    3286
                mstore(0x40, m2)
    3287
                mstore(0x60, m3)
    3288
                mstore(0x80, m4)
    3289
            }
    3290
        }
    3291
    3292
        function log(address p0, address p1, uint256 p2, bool p3) internal pure {
    3293
            bytes32 m0;
    3294
            bytes32 m1;
    3295
            bytes32 m2;
    3296
            bytes32 m3;
    3297
            bytes32 m4;
    3298
            /// @solidity memory-safe-assembly
    3299
            assembly {
    3300
                m0 := mload(0x00)
    3301
                m1 := mload(0x20)
    3302
                m2 := mload(0x40)
    3303
                m3 := mload(0x60)
    3304
                m4 := mload(0x80)
    3305
                // Selector of `log(address,address,uint256,bool)`.
    3306
                mstore(0x00, 0x9b4254e2)
    3307
                mstore(0x20, p0)
    3308
                mstore(0x40, p1)
    3309
                mstore(0x60, p2)
    3310
                mstore(0x80, p3)
    3311
            }
    3312
            _sendLogPayload(0x1c, 0x84);
    3313
            /// @solidity memory-safe-assembly
    3314
            assembly {
    3315
                mstore(0x00, m0)
    3316
                mstore(0x20, m1)
    3317
                mstore(0x40, m2)
    3318
                mstore(0x60, m3)
    3319
                mstore(0x80, m4)
    3320
            }
    3321
        }
    3322
    3323
        function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
    3324
            bytes32 m0;
    3325
            bytes32 m1;
    3326
            bytes32 m2;
    3327
            bytes32 m3;
    3328
            bytes32 m4;
    3329
            /// @solidity memory-safe-assembly
    3330
            assembly {
    3331
                m0 := mload(0x00)
    3332
                m1 := mload(0x20)
    3333
                m2 := mload(0x40)
    3334
                m3 := mload(0x60)
    3335
                m4 := mload(0x80)
    3336
                // Selector of `log(address,address,uint256,uint256)`.
    3337
                mstore(0x00, 0xbe553481)
    3338
                mstore(0x20, p0)
    3339
                mstore(0x40, p1)
    3340
                mstore(0x60, p2)
    3341
                mstore(0x80, p3)
    3342
            }
    3343
            _sendLogPayload(0x1c, 0x84);
    3344
            /// @solidity memory-safe-assembly
    3345
            assembly {
    3346
                mstore(0x00, m0)
    3347
                mstore(0x20, m1)
    3348
                mstore(0x40, m2)
    3349
                mstore(0x60, m3)
    3350
                mstore(0x80, m4)
    3351
            }
    3352
        }
    3353
    3354
        function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {
    3355
            bytes32 m0;
    3356
            bytes32 m1;
    3357
            bytes32 m2;
    3358
            bytes32 m3;
    3359
            bytes32 m4;
    3360
            bytes32 m5;
    3361
            bytes32 m6;
    3362
            /// @solidity memory-safe-assembly
    3363
            assembly {
    3364
                function writeString(pos, w) {
    3365
                    let length := 0
    3366
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3367
                    mstore(pos, length)
    3368
                    let shift := sub(256, shl(3, length))
    3369
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3370
                }
    3371
                m0 := mload(0x00)
    3372
                m1 := mload(0x20)
    3373
                m2 := mload(0x40)
    3374
                m3 := mload(0x60)
    3375
                m4 := mload(0x80)
    3376
                m5 := mload(0xa0)
    3377
                m6 := mload(0xc0)
    3378
                // Selector of `log(address,address,uint256,string)`.
    3379
                mstore(0x00, 0xfdb4f990)
    3380
                mstore(0x20, p0)
    3381
                mstore(0x40, p1)
    3382
                mstore(0x60, p2)
    3383
                mstore(0x80, 0x80)
    3384
                writeString(0xa0, p3)
    3385
            }
    3386
            _sendLogPayload(0x1c, 0xc4);
    3387
            /// @solidity memory-safe-assembly
    3388
            assembly {
    3389
                mstore(0x00, m0)
    3390
                mstore(0x20, m1)
    3391
                mstore(0x40, m2)
    3392
                mstore(0x60, m3)
    3393
                mstore(0x80, m4)
    3394
                mstore(0xa0, m5)
    3395
                mstore(0xc0, m6)
    3396
            }
    3397
        }
    3398
    3399
        function log(address p0, address p1, bytes32 p2, address p3) internal pure {
    3400
            bytes32 m0;
    3401
            bytes32 m1;
    3402
            bytes32 m2;
    3403
            bytes32 m3;
    3404
            bytes32 m4;
    3405
            bytes32 m5;
    3406
            bytes32 m6;
    3407
            /// @solidity memory-safe-assembly
    3408
            assembly {
    3409
                function writeString(pos, w) {
    3410
                    let length := 0
    3411
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3412
                    mstore(pos, length)
    3413
                    let shift := sub(256, shl(3, length))
    3414
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3415
                }
    3416
                m0 := mload(0x00)
    3417
                m1 := mload(0x20)
    3418
                m2 := mload(0x40)
    3419
                m3 := mload(0x60)
    3420
                m4 := mload(0x80)
    3421
                m5 := mload(0xa0)
    3422
                m6 := mload(0xc0)
    3423
                // Selector of `log(address,address,string,address)`.
    3424
                mstore(0x00, 0x8f736d16)
    3425
                mstore(0x20, p0)
    3426
                mstore(0x40, p1)
    3427
                mstore(0x60, 0x80)
    3428
                mstore(0x80, p3)
    3429
                writeString(0xa0, p2)
    3430
            }
    3431
            _sendLogPayload(0x1c, 0xc4);
    3432
            /// @solidity memory-safe-assembly
    3433
            assembly {
    3434
                mstore(0x00, m0)
    3435
                mstore(0x20, m1)
    3436
                mstore(0x40, m2)
    3437
                mstore(0x60, m3)
    3438
                mstore(0x80, m4)
    3439
                mstore(0xa0, m5)
    3440
                mstore(0xc0, m6)
    3441
            }
    3442
        }
    3443
    3444
        function log(address p0, address p1, bytes32 p2, bool p3) internal pure {
    3445
            bytes32 m0;
    3446
            bytes32 m1;
    3447
            bytes32 m2;
    3448
            bytes32 m3;
    3449
            bytes32 m4;
    3450
            bytes32 m5;
    3451
            bytes32 m6;
    3452
            /// @solidity memory-safe-assembly
    3453
            assembly {
    3454
                function writeString(pos, w) {
    3455
                    let length := 0
    3456
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3457
                    mstore(pos, length)
    3458
                    let shift := sub(256, shl(3, length))
    3459
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3460
                }
    3461
                m0 := mload(0x00)
    3462
                m1 := mload(0x20)
    3463
                m2 := mload(0x40)
    3464
                m3 := mload(0x60)
    3465
                m4 := mload(0x80)
    3466
                m5 := mload(0xa0)
    3467
                m6 := mload(0xc0)
    3468
                // Selector of `log(address,address,string,bool)`.
    3469
                mstore(0x00, 0x6f1a594e)
    3470
                mstore(0x20, p0)
    3471
                mstore(0x40, p1)
    3472
                mstore(0x60, 0x80)
    3473
                mstore(0x80, p3)
    3474
                writeString(0xa0, p2)
    3475
            }
    3476
            _sendLogPayload(0x1c, 0xc4);
    3477
            /// @solidity memory-safe-assembly
    3478
            assembly {
    3479
                mstore(0x00, m0)
    3480
                mstore(0x20, m1)
    3481
                mstore(0x40, m2)
    3482
                mstore(0x60, m3)
    3483
                mstore(0x80, m4)
    3484
                mstore(0xa0, m5)
    3485
                mstore(0xc0, m6)
    3486
            }
    3487
        }
    3488
    3489
        function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {
    3490
            bytes32 m0;
    3491
            bytes32 m1;
    3492
            bytes32 m2;
    3493
            bytes32 m3;
    3494
            bytes32 m4;
    3495
            bytes32 m5;
    3496
            bytes32 m6;
    3497
            /// @solidity memory-safe-assembly
    3498
            assembly {
    3499
                function writeString(pos, w) {
    3500
                    let length := 0
    3501
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3502
                    mstore(pos, length)
    3503
                    let shift := sub(256, shl(3, length))
    3504
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3505
                }
    3506
                m0 := mload(0x00)
    3507
                m1 := mload(0x20)
    3508
                m2 := mload(0x40)
    3509
                m3 := mload(0x60)
    3510
                m4 := mload(0x80)
    3511
                m5 := mload(0xa0)
    3512
                m6 := mload(0xc0)
    3513
                // Selector of `log(address,address,string,uint256)`.
    3514
                mstore(0x00, 0xef1cefe7)
    3515
                mstore(0x20, p0)
    3516
                mstore(0x40, p1)
    3517
                mstore(0x60, 0x80)
    3518
                mstore(0x80, p3)
    3519
                writeString(0xa0, p2)
    3520
            }
    3521
            _sendLogPayload(0x1c, 0xc4);
    3522
            /// @solidity memory-safe-assembly
    3523
            assembly {
    3524
                mstore(0x00, m0)
    3525
                mstore(0x20, m1)
    3526
                mstore(0x40, m2)
    3527
                mstore(0x60, m3)
    3528
                mstore(0x80, m4)
    3529
                mstore(0xa0, m5)
    3530
                mstore(0xc0, m6)
    3531
            }
    3532
        }
    3533
    3534
        function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    3535
            bytes32 m0;
    3536
            bytes32 m1;
    3537
            bytes32 m2;
    3538
            bytes32 m3;
    3539
            bytes32 m4;
    3540
            bytes32 m5;
    3541
            bytes32 m6;
    3542
            bytes32 m7;
    3543
            bytes32 m8;
    3544
            /// @solidity memory-safe-assembly
    3545
            assembly {
    3546
                function writeString(pos, w) {
    3547
                    let length := 0
    3548
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3549
                    mstore(pos, length)
    3550
                    let shift := sub(256, shl(3, length))
    3551
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3552
                }
    3553
                m0 := mload(0x00)
    3554
                m1 := mload(0x20)
    3555
                m2 := mload(0x40)
    3556
                m3 := mload(0x60)
    3557
                m4 := mload(0x80)
    3558
                m5 := mload(0xa0)
    3559
                m6 := mload(0xc0)
    3560
                m7 := mload(0xe0)
    3561
                m8 := mload(0x100)
    3562
                // Selector of `log(address,address,string,string)`.
    3563
                mstore(0x00, 0x21bdaf25)
    3564
                mstore(0x20, p0)
    3565
                mstore(0x40, p1)
    3566
                mstore(0x60, 0x80)
    3567
                mstore(0x80, 0xc0)
    3568
                writeString(0xa0, p2)
    3569
                writeString(0xe0, p3)
    3570
            }
    3571
            _sendLogPayload(0x1c, 0x104);
    3572
            /// @solidity memory-safe-assembly
    3573
            assembly {
    3574
                mstore(0x00, m0)
    3575
                mstore(0x20, m1)
    3576
                mstore(0x40, m2)
    3577
                mstore(0x60, m3)
    3578
                mstore(0x80, m4)
    3579
                mstore(0xa0, m5)
    3580
                mstore(0xc0, m6)
    3581
                mstore(0xe0, m7)
    3582
                mstore(0x100, m8)
    3583
            }
    3584
        }
    3585
    3586
        function log(address p0, bool p1, address p2, address p3) internal pure {
    3587
            bytes32 m0;
    3588
            bytes32 m1;
    3589
            bytes32 m2;
    3590
            bytes32 m3;
    3591
            bytes32 m4;
    3592
            /// @solidity memory-safe-assembly
    3593
            assembly {
    3594
                m0 := mload(0x00)
    3595
                m1 := mload(0x20)
    3596
                m2 := mload(0x40)
    3597
                m3 := mload(0x60)
    3598
                m4 := mload(0x80)
    3599
                // Selector of `log(address,bool,address,address)`.
    3600
                mstore(0x00, 0x660375dd)
    3601
                mstore(0x20, p0)
    3602
                mstore(0x40, p1)
    3603
                mstore(0x60, p2)
    3604
                mstore(0x80, p3)
    3605
            }
    3606
            _sendLogPayload(0x1c, 0x84);
    3607
            /// @solidity memory-safe-assembly
    3608
            assembly {
    3609
                mstore(0x00, m0)
    3610
                mstore(0x20, m1)
    3611
                mstore(0x40, m2)
    3612
                mstore(0x60, m3)
    3613
                mstore(0x80, m4)
    3614
            }
    3615
        }
    3616
    3617
        function log(address p0, bool p1, address p2, bool p3) internal pure {
    3618
            bytes32 m0;
    3619
            bytes32 m1;
    3620
            bytes32 m2;
    3621
            bytes32 m3;
    3622
            bytes32 m4;
    3623
            /// @solidity memory-safe-assembly
    3624
            assembly {
    3625
                m0 := mload(0x00)
    3626
                m1 := mload(0x20)
    3627
                m2 := mload(0x40)
    3628
                m3 := mload(0x60)
    3629
                m4 := mload(0x80)
    3630
                // Selector of `log(address,bool,address,bool)`.
    3631
                mstore(0x00, 0xa6f50b0f)
    3632
                mstore(0x20, p0)
    3633
                mstore(0x40, p1)
    3634
                mstore(0x60, p2)
    3635
                mstore(0x80, p3)
    3636
            }
    3637
            _sendLogPayload(0x1c, 0x84);
    3638
            /// @solidity memory-safe-assembly
    3639
            assembly {
    3640
                mstore(0x00, m0)
    3641
                mstore(0x20, m1)
    3642
                mstore(0x40, m2)
    3643
                mstore(0x60, m3)
    3644
                mstore(0x80, m4)
    3645
            }
    3646
        }
    3647
    3648
        function log(address p0, bool p1, address p2, uint256 p3) internal pure {
    3649
            bytes32 m0;
    3650
            bytes32 m1;
    3651
            bytes32 m2;
    3652
            bytes32 m3;
    3653
            bytes32 m4;
    3654
            /// @solidity memory-safe-assembly
    3655
            assembly {
    3656
                m0 := mload(0x00)
    3657
                m1 := mload(0x20)
    3658
                m2 := mload(0x40)
    3659
                m3 := mload(0x60)
    3660
                m4 := mload(0x80)
    3661
                // Selector of `log(address,bool,address,uint256)`.
    3662
                mstore(0x00, 0xa75c59de)
    3663
                mstore(0x20, p0)
    3664
                mstore(0x40, p1)
    3665
                mstore(0x60, p2)
    3666
                mstore(0x80, p3)
    3667
            }
    3668
            _sendLogPayload(0x1c, 0x84);
    3669
            /// @solidity memory-safe-assembly
    3670
            assembly {
    3671
                mstore(0x00, m0)
    3672
                mstore(0x20, m1)
    3673
                mstore(0x40, m2)
    3674
                mstore(0x60, m3)
    3675
                mstore(0x80, m4)
    3676
            }
    3677
        }
    3678
    3679
        function log(address p0, bool p1, address p2, bytes32 p3) internal pure {
    3680
            bytes32 m0;
    3681
            bytes32 m1;
    3682
            bytes32 m2;
    3683
            bytes32 m3;
    3684
            bytes32 m4;
    3685
            bytes32 m5;
    3686
            bytes32 m6;
    3687
            /// @solidity memory-safe-assembly
    3688
            assembly {
    3689
                function writeString(pos, w) {
    3690
                    let length := 0
    3691
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3692
                    mstore(pos, length)
    3693
                    let shift := sub(256, shl(3, length))
    3694
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3695
                }
    3696
                m0 := mload(0x00)
    3697
                m1 := mload(0x20)
    3698
                m2 := mload(0x40)
    3699
                m3 := mload(0x60)
    3700
                m4 := mload(0x80)
    3701
                m5 := mload(0xa0)
    3702
                m6 := mload(0xc0)
    3703
                // Selector of `log(address,bool,address,string)`.
    3704
                mstore(0x00, 0x2dd778e6)
    3705
                mstore(0x20, p0)
    3706
                mstore(0x40, p1)
    3707
                mstore(0x60, p2)
    3708
                mstore(0x80, 0x80)
    3709
                writeString(0xa0, p3)
    3710
            }
    3711
            _sendLogPayload(0x1c, 0xc4);
    3712
            /// @solidity memory-safe-assembly
    3713
            assembly {
    3714
                mstore(0x00, m0)
    3715
                mstore(0x20, m1)
    3716
                mstore(0x40, m2)
    3717
                mstore(0x60, m3)
    3718
                mstore(0x80, m4)
    3719
                mstore(0xa0, m5)
    3720
                mstore(0xc0, m6)
    3721
            }
    3722
        }
    3723
    3724
        function log(address p0, bool p1, bool p2, address p3) internal pure {
    3725
            bytes32 m0;
    3726
            bytes32 m1;
    3727
            bytes32 m2;
    3728
            bytes32 m3;
    3729
            bytes32 m4;
    3730
            /// @solidity memory-safe-assembly
    3731
            assembly {
    3732
                m0 := mload(0x00)
    3733
                m1 := mload(0x20)
    3734
                m2 := mload(0x40)
    3735
                m3 := mload(0x60)
    3736
                m4 := mload(0x80)
    3737
                // Selector of `log(address,bool,bool,address)`.
    3738
                mstore(0x00, 0xcf394485)
    3739
                mstore(0x20, p0)
    3740
                mstore(0x40, p1)
    3741
                mstore(0x60, p2)
    3742
                mstore(0x80, p3)
    3743
            }
    3744
            _sendLogPayload(0x1c, 0x84);
    3745
            /// @solidity memory-safe-assembly
    3746
            assembly {
    3747
                mstore(0x00, m0)
    3748
                mstore(0x20, m1)
    3749
                mstore(0x40, m2)
    3750
                mstore(0x60, m3)
    3751
                mstore(0x80, m4)
    3752
            }
    3753
        }
    3754
    3755
        function log(address p0, bool p1, bool p2, bool p3) internal pure {
    3756
            bytes32 m0;
    3757
            bytes32 m1;
    3758
            bytes32 m2;
    3759
            bytes32 m3;
    3760
            bytes32 m4;
    3761
            /// @solidity memory-safe-assembly
    3762
            assembly {
    3763
                m0 := mload(0x00)
    3764
                m1 := mload(0x20)
    3765
                m2 := mload(0x40)
    3766
                m3 := mload(0x60)
    3767
                m4 := mload(0x80)
    3768
                // Selector of `log(address,bool,bool,bool)`.
    3769
                mstore(0x00, 0xcac43479)
    3770
                mstore(0x20, p0)
    3771
                mstore(0x40, p1)
    3772
                mstore(0x60, p2)
    3773
                mstore(0x80, p3)
    3774
            }
    3775
            _sendLogPayload(0x1c, 0x84);
    3776
            /// @solidity memory-safe-assembly
    3777
            assembly {
    3778
                mstore(0x00, m0)
    3779
                mstore(0x20, m1)
    3780
                mstore(0x40, m2)
    3781
                mstore(0x60, m3)
    3782
                mstore(0x80, m4)
    3783
            }
    3784
        }
    3785
    3786
        function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
    3787
            bytes32 m0;
    3788
            bytes32 m1;
    3789
            bytes32 m2;
    3790
            bytes32 m3;
    3791
            bytes32 m4;
    3792
            /// @solidity memory-safe-assembly
    3793
            assembly {
    3794
                m0 := mload(0x00)
    3795
                m1 := mload(0x20)
    3796
                m2 := mload(0x40)
    3797
                m3 := mload(0x60)
    3798
                m4 := mload(0x80)
    3799
                // Selector of `log(address,bool,bool,uint256)`.
    3800
                mstore(0x00, 0x8c4e5de6)
    3801
                mstore(0x20, p0)
    3802
                mstore(0x40, p1)
    3803
                mstore(0x60, p2)
    3804
                mstore(0x80, p3)
    3805
            }
    3806
            _sendLogPayload(0x1c, 0x84);
    3807
            /// @solidity memory-safe-assembly
    3808
            assembly {
    3809
                mstore(0x00, m0)
    3810
                mstore(0x20, m1)
    3811
                mstore(0x40, m2)
    3812
                mstore(0x60, m3)
    3813
                mstore(0x80, m4)
    3814
            }
    3815
        }
    3816
    3817
        function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {
    3818
            bytes32 m0;
    3819
            bytes32 m1;
    3820
            bytes32 m2;
    3821
            bytes32 m3;
    3822
            bytes32 m4;
    3823
            bytes32 m5;
    3824
            bytes32 m6;
    3825
            /// @solidity memory-safe-assembly
    3826
            assembly {
    3827
                function writeString(pos, w) {
    3828
                    let length := 0
    3829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3830
                    mstore(pos, length)
    3831
                    let shift := sub(256, shl(3, length))
    3832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3833
                }
    3834
                m0 := mload(0x00)
    3835
                m1 := mload(0x20)
    3836
                m2 := mload(0x40)
    3837
                m3 := mload(0x60)
    3838
                m4 := mload(0x80)
    3839
                m5 := mload(0xa0)
    3840
                m6 := mload(0xc0)
    3841
                // Selector of `log(address,bool,bool,string)`.
    3842
                mstore(0x00, 0xdfc4a2e8)
    3843
                mstore(0x20, p0)
    3844
                mstore(0x40, p1)
    3845
                mstore(0x60, p2)
    3846
                mstore(0x80, 0x80)
    3847
                writeString(0xa0, p3)
    3848
            }
    3849
            _sendLogPayload(0x1c, 0xc4);
    3850
            /// @solidity memory-safe-assembly
    3851
            assembly {
    3852
                mstore(0x00, m0)
    3853
                mstore(0x20, m1)
    3854
                mstore(0x40, m2)
    3855
                mstore(0x60, m3)
    3856
                mstore(0x80, m4)
    3857
                mstore(0xa0, m5)
    3858
                mstore(0xc0, m6)
    3859
            }
    3860
        }
    3861
    3862
        function log(address p0, bool p1, uint256 p2, address p3) internal pure {
    3863
            bytes32 m0;
    3864
            bytes32 m1;
    3865
            bytes32 m2;
    3866
            bytes32 m3;
    3867
            bytes32 m4;
    3868
            /// @solidity memory-safe-assembly
    3869
            assembly {
    3870
                m0 := mload(0x00)
    3871
                m1 := mload(0x20)
    3872
                m2 := mload(0x40)
    3873
                m3 := mload(0x60)
    3874
                m4 := mload(0x80)
    3875
                // Selector of `log(address,bool,uint256,address)`.
    3876
                mstore(0x00, 0xccf790a1)
    3877
                mstore(0x20, p0)
    3878
                mstore(0x40, p1)
    3879
                mstore(0x60, p2)
    3880
                mstore(0x80, p3)
    3881
            }
    3882
            _sendLogPayload(0x1c, 0x84);
    3883
            /// @solidity memory-safe-assembly
    3884
            assembly {
    3885
                mstore(0x00, m0)
    3886
                mstore(0x20, m1)
    3887
                mstore(0x40, m2)
    3888
                mstore(0x60, m3)
    3889
                mstore(0x80, m4)
    3890
            }
    3891
        }
    3892
    3893
        function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
    3894
            bytes32 m0;
    3895
            bytes32 m1;
    3896
            bytes32 m2;
    3897
            bytes32 m3;
    3898
            bytes32 m4;
    3899
            /// @solidity memory-safe-assembly
    3900
            assembly {
    3901
                m0 := mload(0x00)
    3902
                m1 := mload(0x20)
    3903
                m2 := mload(0x40)
    3904
                m3 := mload(0x60)
    3905
                m4 := mload(0x80)
    3906
                // Selector of `log(address,bool,uint256,bool)`.
    3907
                mstore(0x00, 0xc4643e20)
    3908
                mstore(0x20, p0)
    3909
                mstore(0x40, p1)
    3910
                mstore(0x60, p2)
    3911
                mstore(0x80, p3)
    3912
            }
    3913
            _sendLogPayload(0x1c, 0x84);
    3914
            /// @solidity memory-safe-assembly
    3915
            assembly {
    3916
                mstore(0x00, m0)
    3917
                mstore(0x20, m1)
    3918
                mstore(0x40, m2)
    3919
                mstore(0x60, m3)
    3920
                mstore(0x80, m4)
    3921
            }
    3922
        }
    3923
    3924
        function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
    3925
            bytes32 m0;
    3926
            bytes32 m1;
    3927
            bytes32 m2;
    3928
            bytes32 m3;
    3929
            bytes32 m4;
    3930
            /// @solidity memory-safe-assembly
    3931
            assembly {
    3932
                m0 := mload(0x00)
    3933
                m1 := mload(0x20)
    3934
                m2 := mload(0x40)
    3935
                m3 := mload(0x60)
    3936
                m4 := mload(0x80)
    3937
                // Selector of `log(address,bool,uint256,uint256)`.
    3938
                mstore(0x00, 0x386ff5f4)
    3939
                mstore(0x20, p0)
    3940
                mstore(0x40, p1)
    3941
                mstore(0x60, p2)
    3942
                mstore(0x80, p3)
    3943
            }
    3944
            _sendLogPayload(0x1c, 0x84);
    3945
            /// @solidity memory-safe-assembly
    3946
            assembly {
    3947
                mstore(0x00, m0)
    3948
                mstore(0x20, m1)
    3949
                mstore(0x40, m2)
    3950
                mstore(0x60, m3)
    3951
                mstore(0x80, m4)
    3952
            }
    3953
        }
    3954
    3955
        function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    3956
            bytes32 m0;
    3957
            bytes32 m1;
    3958
            bytes32 m2;
    3959
            bytes32 m3;
    3960
            bytes32 m4;
    3961
            bytes32 m5;
    3962
            bytes32 m6;
    3963
            /// @solidity memory-safe-assembly
    3964
            assembly {
    3965
                function writeString(pos, w) {
    3966
                    let length := 0
    3967
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    3968
                    mstore(pos, length)
    3969
                    let shift := sub(256, shl(3, length))
    3970
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    3971
                }
    3972
                m0 := mload(0x00)
    3973
                m1 := mload(0x20)
    3974
                m2 := mload(0x40)
    3975
                m3 := mload(0x60)
    3976
                m4 := mload(0x80)
    3977
                m5 := mload(0xa0)
    3978
                m6 := mload(0xc0)
    3979
                // Selector of `log(address,bool,uint256,string)`.
    3980
                mstore(0x00, 0x0aa6cfad)
    3981
                mstore(0x20, p0)
    3982
                mstore(0x40, p1)
    3983
                mstore(0x60, p2)
    3984
                mstore(0x80, 0x80)
    3985
                writeString(0xa0, p3)
    3986
            }
    3987
            _sendLogPayload(0x1c, 0xc4);
    3988
            /// @solidity memory-safe-assembly
    3989
            assembly {
    3990
                mstore(0x00, m0)
    3991
                mstore(0x20, m1)
    3992
                mstore(0x40, m2)
    3993
                mstore(0x60, m3)
    3994
                mstore(0x80, m4)
    3995
                mstore(0xa0, m5)
    3996
                mstore(0xc0, m6)
    3997
            }
    3998
        }
    3999
    4000
        function log(address p0, bool p1, bytes32 p2, address p3) internal pure {
    4001
            bytes32 m0;
    4002
            bytes32 m1;
    4003
            bytes32 m2;
    4004
            bytes32 m3;
    4005
            bytes32 m4;
    4006
            bytes32 m5;
    4007
            bytes32 m6;
    4008
            /// @solidity memory-safe-assembly
    4009
            assembly {
    4010
                function writeString(pos, w) {
    4011
                    let length := 0
    4012
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4013
                    mstore(pos, length)
    4014
                    let shift := sub(256, shl(3, length))
    4015
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4016
                }
    4017
                m0 := mload(0x00)
    4018
                m1 := mload(0x20)
    4019
                m2 := mload(0x40)
    4020
                m3 := mload(0x60)
    4021
                m4 := mload(0x80)
    4022
                m5 := mload(0xa0)
    4023
                m6 := mload(0xc0)
    4024
                // Selector of `log(address,bool,string,address)`.
    4025
                mstore(0x00, 0x19fd4956)
    4026
                mstore(0x20, p0)
    4027
                mstore(0x40, p1)
    4028
                mstore(0x60, 0x80)
    4029
                mstore(0x80, p3)
    4030
                writeString(0xa0, p2)
    4031
            }
    4032
            _sendLogPayload(0x1c, 0xc4);
    4033
            /// @solidity memory-safe-assembly
    4034
            assembly {
    4035
                mstore(0x00, m0)
    4036
                mstore(0x20, m1)
    4037
                mstore(0x40, m2)
    4038
                mstore(0x60, m3)
    4039
                mstore(0x80, m4)
    4040
                mstore(0xa0, m5)
    4041
                mstore(0xc0, m6)
    4042
            }
    4043
        }
    4044
    4045
        function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {
    4046
            bytes32 m0;
    4047
            bytes32 m1;
    4048
            bytes32 m2;
    4049
            bytes32 m3;
    4050
            bytes32 m4;
    4051
            bytes32 m5;
    4052
            bytes32 m6;
    4053
            /// @solidity memory-safe-assembly
    4054
            assembly {
    4055
                function writeString(pos, w) {
    4056
                    let length := 0
    4057
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4058
                    mstore(pos, length)
    4059
                    let shift := sub(256, shl(3, length))
    4060
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4061
                }
    4062
                m0 := mload(0x00)
    4063
                m1 := mload(0x20)
    4064
                m2 := mload(0x40)
    4065
                m3 := mload(0x60)
    4066
                m4 := mload(0x80)
    4067
                m5 := mload(0xa0)
    4068
                m6 := mload(0xc0)
    4069
                // Selector of `log(address,bool,string,bool)`.
    4070
                mstore(0x00, 0x50ad461d)
    4071
                mstore(0x20, p0)
    4072
                mstore(0x40, p1)
    4073
                mstore(0x60, 0x80)
    4074
                mstore(0x80, p3)
    4075
                writeString(0xa0, p2)
    4076
            }
    4077
            _sendLogPayload(0x1c, 0xc4);
    4078
            /// @solidity memory-safe-assembly
    4079
            assembly {
    4080
                mstore(0x00, m0)
    4081
                mstore(0x20, m1)
    4082
                mstore(0x40, m2)
    4083
                mstore(0x60, m3)
    4084
                mstore(0x80, m4)
    4085
                mstore(0xa0, m5)
    4086
                mstore(0xc0, m6)
    4087
            }
    4088
        }
    4089
    4090
        function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    4091
            bytes32 m0;
    4092
            bytes32 m1;
    4093
            bytes32 m2;
    4094
            bytes32 m3;
    4095
            bytes32 m4;
    4096
            bytes32 m5;
    4097
            bytes32 m6;
    4098
            /// @solidity memory-safe-assembly
    4099
            assembly {
    4100
                function writeString(pos, w) {
    4101
                    let length := 0
    4102
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4103
                    mstore(pos, length)
    4104
                    let shift := sub(256, shl(3, length))
    4105
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4106
                }
    4107
                m0 := mload(0x00)
    4108
                m1 := mload(0x20)
    4109
                m2 := mload(0x40)
    4110
                m3 := mload(0x60)
    4111
                m4 := mload(0x80)
    4112
                m5 := mload(0xa0)
    4113
                m6 := mload(0xc0)
    4114
                // Selector of `log(address,bool,string,uint256)`.
    4115
                mstore(0x00, 0x80e6a20b)
    4116
                mstore(0x20, p0)
    4117
                mstore(0x40, p1)
    4118
                mstore(0x60, 0x80)
    4119
                mstore(0x80, p3)
    4120
                writeString(0xa0, p2)
    4121
            }
    4122
            _sendLogPayload(0x1c, 0xc4);
    4123
            /// @solidity memory-safe-assembly
    4124
            assembly {
    4125
                mstore(0x00, m0)
    4126
                mstore(0x20, m1)
    4127
                mstore(0x40, m2)
    4128
                mstore(0x60, m3)
    4129
                mstore(0x80, m4)
    4130
                mstore(0xa0, m5)
    4131
                mstore(0xc0, m6)
    4132
            }
    4133
        }
    4134
    4135
        function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    4136
            bytes32 m0;
    4137
            bytes32 m1;
    4138
            bytes32 m2;
    4139
            bytes32 m3;
    4140
            bytes32 m4;
    4141
            bytes32 m5;
    4142
            bytes32 m6;
    4143
            bytes32 m7;
    4144
            bytes32 m8;
    4145
            /// @solidity memory-safe-assembly
    4146
            assembly {
    4147
                function writeString(pos, w) {
    4148
                    let length := 0
    4149
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4150
                    mstore(pos, length)
    4151
                    let shift := sub(256, shl(3, length))
    4152
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4153
                }
    4154
                m0 := mload(0x00)
    4155
                m1 := mload(0x20)
    4156
                m2 := mload(0x40)
    4157
                m3 := mload(0x60)
    4158
                m4 := mload(0x80)
    4159
                m5 := mload(0xa0)
    4160
                m6 := mload(0xc0)
    4161
                m7 := mload(0xe0)
    4162
                m8 := mload(0x100)
    4163
                // Selector of `log(address,bool,string,string)`.
    4164
                mstore(0x00, 0x475c5c33)
    4165
                mstore(0x20, p0)
    4166
                mstore(0x40, p1)
    4167
                mstore(0x60, 0x80)
    4168
                mstore(0x80, 0xc0)
    4169
                writeString(0xa0, p2)
    4170
                writeString(0xe0, p3)
    4171
            }
    4172
            _sendLogPayload(0x1c, 0x104);
    4173
            /// @solidity memory-safe-assembly
    4174
            assembly {
    4175
                mstore(0x00, m0)
    4176
                mstore(0x20, m1)
    4177
                mstore(0x40, m2)
    4178
                mstore(0x60, m3)
    4179
                mstore(0x80, m4)
    4180
                mstore(0xa0, m5)
    4181
                mstore(0xc0, m6)
    4182
                mstore(0xe0, m7)
    4183
                mstore(0x100, m8)
    4184
            }
    4185
        }
    4186
    4187
        function log(address p0, uint256 p1, address p2, address p3) internal pure {
    4188
            bytes32 m0;
    4189
            bytes32 m1;
    4190
            bytes32 m2;
    4191
            bytes32 m3;
    4192
            bytes32 m4;
    4193
            /// @solidity memory-safe-assembly
    4194
            assembly {
    4195
                m0 := mload(0x00)
    4196
                m1 := mload(0x20)
    4197
                m2 := mload(0x40)
    4198
                m3 := mload(0x60)
    4199
                m4 := mload(0x80)
    4200
                // Selector of `log(address,uint256,address,address)`.
    4201
                mstore(0x00, 0x478d1c62)
    4202
                mstore(0x20, p0)
    4203
                mstore(0x40, p1)
    4204
                mstore(0x60, p2)
    4205
                mstore(0x80, p3)
    4206
            }
    4207
            _sendLogPayload(0x1c, 0x84);
    4208
            /// @solidity memory-safe-assembly
    4209
            assembly {
    4210
                mstore(0x00, m0)
    4211
                mstore(0x20, m1)
    4212
                mstore(0x40, m2)
    4213
                mstore(0x60, m3)
    4214
                mstore(0x80, m4)
    4215
            }
    4216
        }
    4217
    4218
        function log(address p0, uint256 p1, address p2, bool p3) internal pure {
    4219
            bytes32 m0;
    4220
            bytes32 m1;
    4221
            bytes32 m2;
    4222
            bytes32 m3;
    4223
            bytes32 m4;
    4224
            /// @solidity memory-safe-assembly
    4225
            assembly {
    4226
                m0 := mload(0x00)
    4227
                m1 := mload(0x20)
    4228
                m2 := mload(0x40)
    4229
                m3 := mload(0x60)
    4230
                m4 := mload(0x80)
    4231
                // Selector of `log(address,uint256,address,bool)`.
    4232
                mstore(0x00, 0xa1bcc9b3)
    4233
                mstore(0x20, p0)
    4234
                mstore(0x40, p1)
    4235
                mstore(0x60, p2)
    4236
                mstore(0x80, p3)
    4237
            }
    4238
            _sendLogPayload(0x1c, 0x84);
    4239
            /// @solidity memory-safe-assembly
    4240
            assembly {
    4241
                mstore(0x00, m0)
    4242
                mstore(0x20, m1)
    4243
                mstore(0x40, m2)
    4244
                mstore(0x60, m3)
    4245
                mstore(0x80, m4)
    4246
            }
    4247
        }
    4248
    4249
        function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
    4250
            bytes32 m0;
    4251
            bytes32 m1;
    4252
            bytes32 m2;
    4253
            bytes32 m3;
    4254
            bytes32 m4;
    4255
            /// @solidity memory-safe-assembly
    4256
            assembly {
    4257
                m0 := mload(0x00)
    4258
                m1 := mload(0x20)
    4259
                m2 := mload(0x40)
    4260
                m3 := mload(0x60)
    4261
                m4 := mload(0x80)
    4262
                // Selector of `log(address,uint256,address,uint256)`.
    4263
                mstore(0x00, 0x100f650e)
    4264
                mstore(0x20, p0)
    4265
                mstore(0x40, p1)
    4266
                mstore(0x60, p2)
    4267
                mstore(0x80, p3)
    4268
            }
    4269
            _sendLogPayload(0x1c, 0x84);
    4270
            /// @solidity memory-safe-assembly
    4271
            assembly {
    4272
                mstore(0x00, m0)
    4273
                mstore(0x20, m1)
    4274
                mstore(0x40, m2)
    4275
                mstore(0x60, m3)
    4276
                mstore(0x80, m4)
    4277
            }
    4278
        }
    4279
    4280
        function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {
    4281
            bytes32 m0;
    4282
            bytes32 m1;
    4283
            bytes32 m2;
    4284
            bytes32 m3;
    4285
            bytes32 m4;
    4286
            bytes32 m5;
    4287
            bytes32 m6;
    4288
            /// @solidity memory-safe-assembly
    4289
            assembly {
    4290
                function writeString(pos, w) {
    4291
                    let length := 0
    4292
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4293
                    mstore(pos, length)
    4294
                    let shift := sub(256, shl(3, length))
    4295
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4296
                }
    4297
                m0 := mload(0x00)
    4298
                m1 := mload(0x20)
    4299
                m2 := mload(0x40)
    4300
                m3 := mload(0x60)
    4301
                m4 := mload(0x80)
    4302
                m5 := mload(0xa0)
    4303
                m6 := mload(0xc0)
    4304
                // Selector of `log(address,uint256,address,string)`.
    4305
                mstore(0x00, 0x1da986ea)
    4306
                mstore(0x20, p0)
    4307
                mstore(0x40, p1)
    4308
                mstore(0x60, p2)
    4309
                mstore(0x80, 0x80)
    4310
                writeString(0xa0, p3)
    4311
            }
    4312
            _sendLogPayload(0x1c, 0xc4);
    4313
            /// @solidity memory-safe-assembly
    4314
            assembly {
    4315
                mstore(0x00, m0)
    4316
                mstore(0x20, m1)
    4317
                mstore(0x40, m2)
    4318
                mstore(0x60, m3)
    4319
                mstore(0x80, m4)
    4320
                mstore(0xa0, m5)
    4321
                mstore(0xc0, m6)
    4322
            }
    4323
        }
    4324
    4325
        function log(address p0, uint256 p1, bool p2, address p3) internal pure {
    4326
            bytes32 m0;
    4327
            bytes32 m1;
    4328
            bytes32 m2;
    4329
            bytes32 m3;
    4330
            bytes32 m4;
    4331
            /// @solidity memory-safe-assembly
    4332
            assembly {
    4333
                m0 := mload(0x00)
    4334
                m1 := mload(0x20)
    4335
                m2 := mload(0x40)
    4336
                m3 := mload(0x60)
    4337
                m4 := mload(0x80)
    4338
                // Selector of `log(address,uint256,bool,address)`.
    4339
                mstore(0x00, 0xa31bfdcc)
    4340
                mstore(0x20, p0)
    4341
                mstore(0x40, p1)
    4342
                mstore(0x60, p2)
    4343
                mstore(0x80, p3)
    4344
            }
    4345
            _sendLogPayload(0x1c, 0x84);
    4346
            /// @solidity memory-safe-assembly
    4347
            assembly {
    4348
                mstore(0x00, m0)
    4349
                mstore(0x20, m1)
    4350
                mstore(0x40, m2)
    4351
                mstore(0x60, m3)
    4352
                mstore(0x80, m4)
    4353
            }
    4354
        }
    4355
    4356
        function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
    4357
            bytes32 m0;
    4358
            bytes32 m1;
    4359
            bytes32 m2;
    4360
            bytes32 m3;
    4361
            bytes32 m4;
    4362
            /// @solidity memory-safe-assembly
    4363
            assembly {
    4364
                m0 := mload(0x00)
    4365
                m1 := mload(0x20)
    4366
                m2 := mload(0x40)
    4367
                m3 := mload(0x60)
    4368
                m4 := mload(0x80)
    4369
                // Selector of `log(address,uint256,bool,bool)`.
    4370
                mstore(0x00, 0x3bf5e537)
    4371
                mstore(0x20, p0)
    4372
                mstore(0x40, p1)
    4373
                mstore(0x60, p2)
    4374
                mstore(0x80, p3)
    4375
            }
    4376
            _sendLogPayload(0x1c, 0x84);
    4377
            /// @solidity memory-safe-assembly
    4378
            assembly {
    4379
                mstore(0x00, m0)
    4380
                mstore(0x20, m1)
    4381
                mstore(0x40, m2)
    4382
                mstore(0x60, m3)
    4383
                mstore(0x80, m4)
    4384
            }
    4385
        }
    4386
    4387
        function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
    4388
            bytes32 m0;
    4389
            bytes32 m1;
    4390
            bytes32 m2;
    4391
            bytes32 m3;
    4392
            bytes32 m4;
    4393
            /// @solidity memory-safe-assembly
    4394
            assembly {
    4395
                m0 := mload(0x00)
    4396
                m1 := mload(0x20)
    4397
                m2 := mload(0x40)
    4398
                m3 := mload(0x60)
    4399
                m4 := mload(0x80)
    4400
                // Selector of `log(address,uint256,bool,uint256)`.
    4401
                mstore(0x00, 0x22f6b999)
    4402
                mstore(0x20, p0)
    4403
                mstore(0x40, p1)
    4404
                mstore(0x60, p2)
    4405
                mstore(0x80, p3)
    4406
            }
    4407
            _sendLogPayload(0x1c, 0x84);
    4408
            /// @solidity memory-safe-assembly
    4409
            assembly {
    4410
                mstore(0x00, m0)
    4411
                mstore(0x20, m1)
    4412
                mstore(0x40, m2)
    4413
                mstore(0x60, m3)
    4414
                mstore(0x80, m4)
    4415
            }
    4416
        }
    4417
    4418
        function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    4419
            bytes32 m0;
    4420
            bytes32 m1;
    4421
            bytes32 m2;
    4422
            bytes32 m3;
    4423
            bytes32 m4;
    4424
            bytes32 m5;
    4425
            bytes32 m6;
    4426
            /// @solidity memory-safe-assembly
    4427
            assembly {
    4428
                function writeString(pos, w) {
    4429
                    let length := 0
    4430
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4431
                    mstore(pos, length)
    4432
                    let shift := sub(256, shl(3, length))
    4433
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4434
                }
    4435
                m0 := mload(0x00)
    4436
                m1 := mload(0x20)
    4437
                m2 := mload(0x40)
    4438
                m3 := mload(0x60)
    4439
                m4 := mload(0x80)
    4440
                m5 := mload(0xa0)
    4441
                m6 := mload(0xc0)
    4442
                // Selector of `log(address,uint256,bool,string)`.
    4443
                mstore(0x00, 0xc5ad85f9)
    4444
                mstore(0x20, p0)
    4445
                mstore(0x40, p1)
    4446
                mstore(0x60, p2)
    4447
                mstore(0x80, 0x80)
    4448
                writeString(0xa0, p3)
    4449
            }
    4450
            _sendLogPayload(0x1c, 0xc4);
    4451
            /// @solidity memory-safe-assembly
    4452
            assembly {
    4453
                mstore(0x00, m0)
    4454
                mstore(0x20, m1)
    4455
                mstore(0x40, m2)
    4456
                mstore(0x60, m3)
    4457
                mstore(0x80, m4)
    4458
                mstore(0xa0, m5)
    4459
                mstore(0xc0, m6)
    4460
            }
    4461
        }
    4462
    4463
        function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
    4464
            bytes32 m0;
    4465
            bytes32 m1;
    4466
            bytes32 m2;
    4467
            bytes32 m3;
    4468
            bytes32 m4;
    4469
            /// @solidity memory-safe-assembly
    4470
            assembly {
    4471
                m0 := mload(0x00)
    4472
                m1 := mload(0x20)
    4473
                m2 := mload(0x40)
    4474
                m3 := mload(0x60)
    4475
                m4 := mload(0x80)
    4476
                // Selector of `log(address,uint256,uint256,address)`.
    4477
                mstore(0x00, 0x20e3984d)
    4478
                mstore(0x20, p0)
    4479
                mstore(0x40, p1)
    4480
                mstore(0x60, p2)
    4481
                mstore(0x80, p3)
    4482
            }
    4483
            _sendLogPayload(0x1c, 0x84);
    4484
            /// @solidity memory-safe-assembly
    4485
            assembly {
    4486
                mstore(0x00, m0)
    4487
                mstore(0x20, m1)
    4488
                mstore(0x40, m2)
    4489
                mstore(0x60, m3)
    4490
                mstore(0x80, m4)
    4491
            }
    4492
        }
    4493
    4494
        function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
    4495
            bytes32 m0;
    4496
            bytes32 m1;
    4497
            bytes32 m2;
    4498
            bytes32 m3;
    4499
            bytes32 m4;
    4500
            /// @solidity memory-safe-assembly
    4501
            assembly {
    4502
                m0 := mload(0x00)
    4503
                m1 := mload(0x20)
    4504
                m2 := mload(0x40)
    4505
                m3 := mload(0x60)
    4506
                m4 := mload(0x80)
    4507
                // Selector of `log(address,uint256,uint256,bool)`.
    4508
                mstore(0x00, 0x66f1bc67)
    4509
                mstore(0x20, p0)
    4510
                mstore(0x40, p1)
    4511
                mstore(0x60, p2)
    4512
                mstore(0x80, p3)
    4513
            }
    4514
            _sendLogPayload(0x1c, 0x84);
    4515
            /// @solidity memory-safe-assembly
    4516
            assembly {
    4517
                mstore(0x00, m0)
    4518
                mstore(0x20, m1)
    4519
                mstore(0x40, m2)
    4520
                mstore(0x60, m3)
    4521
                mstore(0x80, m4)
    4522
            }
    4523
        }
    4524
    4525
        function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    4526
            bytes32 m0;
    4527
            bytes32 m1;
    4528
            bytes32 m2;
    4529
            bytes32 m3;
    4530
            bytes32 m4;
    4531
            /// @solidity memory-safe-assembly
    4532
            assembly {
    4533
                m0 := mload(0x00)
    4534
                m1 := mload(0x20)
    4535
                m2 := mload(0x40)
    4536
                m3 := mload(0x60)
    4537
                m4 := mload(0x80)
    4538
                // Selector of `log(address,uint256,uint256,uint256)`.
    4539
                mstore(0x00, 0x34f0e636)
    4540
                mstore(0x20, p0)
    4541
                mstore(0x40, p1)
    4542
                mstore(0x60, p2)
    4543
                mstore(0x80, p3)
    4544
            }
    4545
            _sendLogPayload(0x1c, 0x84);
    4546
            /// @solidity memory-safe-assembly
    4547
            assembly {
    4548
                mstore(0x00, m0)
    4549
                mstore(0x20, m1)
    4550
                mstore(0x40, m2)
    4551
                mstore(0x60, m3)
    4552
                mstore(0x80, m4)
    4553
            }
    4554
        }
    4555
    4556
        function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    4557
            bytes32 m0;
    4558
            bytes32 m1;
    4559
            bytes32 m2;
    4560
            bytes32 m3;
    4561
            bytes32 m4;
    4562
            bytes32 m5;
    4563
            bytes32 m6;
    4564
            /// @solidity memory-safe-assembly
    4565
            assembly {
    4566
                function writeString(pos, w) {
    4567
                    let length := 0
    4568
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4569
                    mstore(pos, length)
    4570
                    let shift := sub(256, shl(3, length))
    4571
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4572
                }
    4573
                m0 := mload(0x00)
    4574
                m1 := mload(0x20)
    4575
                m2 := mload(0x40)
    4576
                m3 := mload(0x60)
    4577
                m4 := mload(0x80)
    4578
                m5 := mload(0xa0)
    4579
                m6 := mload(0xc0)
    4580
                // Selector of `log(address,uint256,uint256,string)`.
    4581
                mstore(0x00, 0x4a28c017)
    4582
                mstore(0x20, p0)
    4583
                mstore(0x40, p1)
    4584
                mstore(0x60, p2)
    4585
                mstore(0x80, 0x80)
    4586
                writeString(0xa0, p3)
    4587
            }
    4588
            _sendLogPayload(0x1c, 0xc4);
    4589
            /// @solidity memory-safe-assembly
    4590
            assembly {
    4591
                mstore(0x00, m0)
    4592
                mstore(0x20, m1)
    4593
                mstore(0x40, m2)
    4594
                mstore(0x60, m3)
    4595
                mstore(0x80, m4)
    4596
                mstore(0xa0, m5)
    4597
                mstore(0xc0, m6)
    4598
            }
    4599
        }
    4600
    4601
        function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {
    4602
            bytes32 m0;
    4603
            bytes32 m1;
    4604
            bytes32 m2;
    4605
            bytes32 m3;
    4606
            bytes32 m4;
    4607
            bytes32 m5;
    4608
            bytes32 m6;
    4609
            /// @solidity memory-safe-assembly
    4610
            assembly {
    4611
                function writeString(pos, w) {
    4612
                    let length := 0
    4613
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4614
                    mstore(pos, length)
    4615
                    let shift := sub(256, shl(3, length))
    4616
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4617
                }
    4618
                m0 := mload(0x00)
    4619
                m1 := mload(0x20)
    4620
                m2 := mload(0x40)
    4621
                m3 := mload(0x60)
    4622
                m4 := mload(0x80)
    4623
                m5 := mload(0xa0)
    4624
                m6 := mload(0xc0)
    4625
                // Selector of `log(address,uint256,string,address)`.
    4626
                mstore(0x00, 0x5c430d47)
    4627
                mstore(0x20, p0)
    4628
                mstore(0x40, p1)
    4629
                mstore(0x60, 0x80)
    4630
                mstore(0x80, p3)
    4631
                writeString(0xa0, p2)
    4632
            }
    4633
            _sendLogPayload(0x1c, 0xc4);
    4634
            /// @solidity memory-safe-assembly
    4635
            assembly {
    4636
                mstore(0x00, m0)
    4637
                mstore(0x20, m1)
    4638
                mstore(0x40, m2)
    4639
                mstore(0x60, m3)
    4640
                mstore(0x80, m4)
    4641
                mstore(0xa0, m5)
    4642
                mstore(0xc0, m6)
    4643
            }
    4644
        }
    4645
    4646
        function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    4647
            bytes32 m0;
    4648
            bytes32 m1;
    4649
            bytes32 m2;
    4650
            bytes32 m3;
    4651
            bytes32 m4;
    4652
            bytes32 m5;
    4653
            bytes32 m6;
    4654
            /// @solidity memory-safe-assembly
    4655
            assembly {
    4656
                function writeString(pos, w) {
    4657
                    let length := 0
    4658
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4659
                    mstore(pos, length)
    4660
                    let shift := sub(256, shl(3, length))
    4661
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4662
                }
    4663
                m0 := mload(0x00)
    4664
                m1 := mload(0x20)
    4665
                m2 := mload(0x40)
    4666
                m3 := mload(0x60)
    4667
                m4 := mload(0x80)
    4668
                m5 := mload(0xa0)
    4669
                m6 := mload(0xc0)
    4670
                // Selector of `log(address,uint256,string,bool)`.
    4671
                mstore(0x00, 0xcf18105c)
    4672
                mstore(0x20, p0)
    4673
                mstore(0x40, p1)
    4674
                mstore(0x60, 0x80)
    4675
                mstore(0x80, p3)
    4676
                writeString(0xa0, p2)
    4677
            }
    4678
            _sendLogPayload(0x1c, 0xc4);
    4679
            /// @solidity memory-safe-assembly
    4680
            assembly {
    4681
                mstore(0x00, m0)
    4682
                mstore(0x20, m1)
    4683
                mstore(0x40, m2)
    4684
                mstore(0x60, m3)
    4685
                mstore(0x80, m4)
    4686
                mstore(0xa0, m5)
    4687
                mstore(0xc0, m6)
    4688
            }
    4689
        }
    4690
    4691
        function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    4692
            bytes32 m0;
    4693
            bytes32 m1;
    4694
            bytes32 m2;
    4695
            bytes32 m3;
    4696
            bytes32 m4;
    4697
            bytes32 m5;
    4698
            bytes32 m6;
    4699
            /// @solidity memory-safe-assembly
    4700
            assembly {
    4701
                function writeString(pos, w) {
    4702
                    let length := 0
    4703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4704
                    mstore(pos, length)
    4705
                    let shift := sub(256, shl(3, length))
    4706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4707
                }
    4708
                m0 := mload(0x00)
    4709
                m1 := mload(0x20)
    4710
                m2 := mload(0x40)
    4711
                m3 := mload(0x60)
    4712
                m4 := mload(0x80)
    4713
                m5 := mload(0xa0)
    4714
                m6 := mload(0xc0)
    4715
                // Selector of `log(address,uint256,string,uint256)`.
    4716
                mstore(0x00, 0xbf01f891)
    4717
                mstore(0x20, p0)
    4718
                mstore(0x40, p1)
    4719
                mstore(0x60, 0x80)
    4720
                mstore(0x80, p3)
    4721
                writeString(0xa0, p2)
    4722
            }
    4723
            _sendLogPayload(0x1c, 0xc4);
    4724
            /// @solidity memory-safe-assembly
    4725
            assembly {
    4726
                mstore(0x00, m0)
    4727
                mstore(0x20, m1)
    4728
                mstore(0x40, m2)
    4729
                mstore(0x60, m3)
    4730
                mstore(0x80, m4)
    4731
                mstore(0xa0, m5)
    4732
                mstore(0xc0, m6)
    4733
            }
    4734
        }
    4735
    4736
        function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    4737
            bytes32 m0;
    4738
            bytes32 m1;
    4739
            bytes32 m2;
    4740
            bytes32 m3;
    4741
            bytes32 m4;
    4742
            bytes32 m5;
    4743
            bytes32 m6;
    4744
            bytes32 m7;
    4745
            bytes32 m8;
    4746
            /// @solidity memory-safe-assembly
    4747
            assembly {
    4748
                function writeString(pos, w) {
    4749
                    let length := 0
    4750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4751
                    mstore(pos, length)
    4752
                    let shift := sub(256, shl(3, length))
    4753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4754
                }
    4755
                m0 := mload(0x00)
    4756
                m1 := mload(0x20)
    4757
                m2 := mload(0x40)
    4758
                m3 := mload(0x60)
    4759
                m4 := mload(0x80)
    4760
                m5 := mload(0xa0)
    4761
                m6 := mload(0xc0)
    4762
                m7 := mload(0xe0)
    4763
                m8 := mload(0x100)
    4764
                // Selector of `log(address,uint256,string,string)`.
    4765
                mstore(0x00, 0x88a8c406)
    4766
                mstore(0x20, p0)
    4767
                mstore(0x40, p1)
    4768
                mstore(0x60, 0x80)
    4769
                mstore(0x80, 0xc0)
    4770
                writeString(0xa0, p2)
    4771
                writeString(0xe0, p3)
    4772
            }
    4773
            _sendLogPayload(0x1c, 0x104);
    4774
            /// @solidity memory-safe-assembly
    4775
            assembly {
    4776
                mstore(0x00, m0)
    4777
                mstore(0x20, m1)
    4778
                mstore(0x40, m2)
    4779
                mstore(0x60, m3)
    4780
                mstore(0x80, m4)
    4781
                mstore(0xa0, m5)
    4782
                mstore(0xc0, m6)
    4783
                mstore(0xe0, m7)
    4784
                mstore(0x100, m8)
    4785
            }
    4786
        }
    4787
    4788
        function log(address p0, bytes32 p1, address p2, address p3) internal pure {
    4789
            bytes32 m0;
    4790
            bytes32 m1;
    4791
            bytes32 m2;
    4792
            bytes32 m3;
    4793
            bytes32 m4;
    4794
            bytes32 m5;
    4795
            bytes32 m6;
    4796
            /// @solidity memory-safe-assembly
    4797
            assembly {
    4798
                function writeString(pos, w) {
    4799
                    let length := 0
    4800
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4801
                    mstore(pos, length)
    4802
                    let shift := sub(256, shl(3, length))
    4803
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4804
                }
    4805
                m0 := mload(0x00)
    4806
                m1 := mload(0x20)
    4807
                m2 := mload(0x40)
    4808
                m3 := mload(0x60)
    4809
                m4 := mload(0x80)
    4810
                m5 := mload(0xa0)
    4811
                m6 := mload(0xc0)
    4812
                // Selector of `log(address,string,address,address)`.
    4813
                mstore(0x00, 0x0d36fa20)
    4814
                mstore(0x20, p0)
    4815
                mstore(0x40, 0x80)
    4816
                mstore(0x60, p2)
    4817
                mstore(0x80, p3)
    4818
                writeString(0xa0, p1)
    4819
            }
    4820
            _sendLogPayload(0x1c, 0xc4);
    4821
            /// @solidity memory-safe-assembly
    4822
            assembly {
    4823
                mstore(0x00, m0)
    4824
                mstore(0x20, m1)
    4825
                mstore(0x40, m2)
    4826
                mstore(0x60, m3)
    4827
                mstore(0x80, m4)
    4828
                mstore(0xa0, m5)
    4829
                mstore(0xc0, m6)
    4830
            }
    4831
        }
    4832
    4833
        function log(address p0, bytes32 p1, address p2, bool p3) internal pure {
    4834
            bytes32 m0;
    4835
            bytes32 m1;
    4836
            bytes32 m2;
    4837
            bytes32 m3;
    4838
            bytes32 m4;
    4839
            bytes32 m5;
    4840
            bytes32 m6;
    4841
            /// @solidity memory-safe-assembly
    4842
            assembly {
    4843
                function writeString(pos, w) {
    4844
                    let length := 0
    4845
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4846
                    mstore(pos, length)
    4847
                    let shift := sub(256, shl(3, length))
    4848
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4849
                }
    4850
                m0 := mload(0x00)
    4851
                m1 := mload(0x20)
    4852
                m2 := mload(0x40)
    4853
                m3 := mload(0x60)
    4854
                m4 := mload(0x80)
    4855
                m5 := mload(0xa0)
    4856
                m6 := mload(0xc0)
    4857
                // Selector of `log(address,string,address,bool)`.
    4858
                mstore(0x00, 0x0df12b76)
    4859
                mstore(0x20, p0)
    4860
                mstore(0x40, 0x80)
    4861
                mstore(0x60, p2)
    4862
                mstore(0x80, p3)
    4863
                writeString(0xa0, p1)
    4864
            }
    4865
            _sendLogPayload(0x1c, 0xc4);
    4866
            /// @solidity memory-safe-assembly
    4867
            assembly {
    4868
                mstore(0x00, m0)
    4869
                mstore(0x20, m1)
    4870
                mstore(0x40, m2)
    4871
                mstore(0x60, m3)
    4872
                mstore(0x80, m4)
    4873
                mstore(0xa0, m5)
    4874
                mstore(0xc0, m6)
    4875
            }
    4876
        }
    4877
    4878
        function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {
    4879
            bytes32 m0;
    4880
            bytes32 m1;
    4881
            bytes32 m2;
    4882
            bytes32 m3;
    4883
            bytes32 m4;
    4884
            bytes32 m5;
    4885
            bytes32 m6;
    4886
            /// @solidity memory-safe-assembly
    4887
            assembly {
    4888
                function writeString(pos, w) {
    4889
                    let length := 0
    4890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4891
                    mstore(pos, length)
    4892
                    let shift := sub(256, shl(3, length))
    4893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4894
                }
    4895
                m0 := mload(0x00)
    4896
                m1 := mload(0x20)
    4897
                m2 := mload(0x40)
    4898
                m3 := mload(0x60)
    4899
                m4 := mload(0x80)
    4900
                m5 := mload(0xa0)
    4901
                m6 := mload(0xc0)
    4902
                // Selector of `log(address,string,address,uint256)`.
    4903
                mstore(0x00, 0x457fe3cf)
    4904
                mstore(0x20, p0)
    4905
                mstore(0x40, 0x80)
    4906
                mstore(0x60, p2)
    4907
                mstore(0x80, p3)
    4908
                writeString(0xa0, p1)
    4909
            }
    4910
            _sendLogPayload(0x1c, 0xc4);
    4911
            /// @solidity memory-safe-assembly
    4912
            assembly {
    4913
                mstore(0x00, m0)
    4914
                mstore(0x20, m1)
    4915
                mstore(0x40, m2)
    4916
                mstore(0x60, m3)
    4917
                mstore(0x80, m4)
    4918
                mstore(0xa0, m5)
    4919
                mstore(0xc0, m6)
    4920
            }
    4921
        }
    4922
    4923
        function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    4924
            bytes32 m0;
    4925
            bytes32 m1;
    4926
            bytes32 m2;
    4927
            bytes32 m3;
    4928
            bytes32 m4;
    4929
            bytes32 m5;
    4930
            bytes32 m6;
    4931
            bytes32 m7;
    4932
            bytes32 m8;
    4933
            /// @solidity memory-safe-assembly
    4934
            assembly {
    4935
                function writeString(pos, w) {
    4936
                    let length := 0
    4937
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4938
                    mstore(pos, length)
    4939
                    let shift := sub(256, shl(3, length))
    4940
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4941
                }
    4942
                m0 := mload(0x00)
    4943
                m1 := mload(0x20)
    4944
                m2 := mload(0x40)
    4945
                m3 := mload(0x60)
    4946
                m4 := mload(0x80)
    4947
                m5 := mload(0xa0)
    4948
                m6 := mload(0xc0)
    4949
                m7 := mload(0xe0)
    4950
                m8 := mload(0x100)
    4951
                // Selector of `log(address,string,address,string)`.
    4952
                mstore(0x00, 0xf7e36245)
    4953
                mstore(0x20, p0)
    4954
                mstore(0x40, 0x80)
    4955
                mstore(0x60, p2)
    4956
                mstore(0x80, 0xc0)
    4957
                writeString(0xa0, p1)
    4958
                writeString(0xe0, p3)
    4959
            }
    4960
            _sendLogPayload(0x1c, 0x104);
    4961
            /// @solidity memory-safe-assembly
    4962
            assembly {
    4963
                mstore(0x00, m0)
    4964
                mstore(0x20, m1)
    4965
                mstore(0x40, m2)
    4966
                mstore(0x60, m3)
    4967
                mstore(0x80, m4)
    4968
                mstore(0xa0, m5)
    4969
                mstore(0xc0, m6)
    4970
                mstore(0xe0, m7)
    4971
                mstore(0x100, m8)
    4972
            }
    4973
        }
    4974
    4975
        function log(address p0, bytes32 p1, bool p2, address p3) internal pure {
    4976
            bytes32 m0;
    4977
            bytes32 m1;
    4978
            bytes32 m2;
    4979
            bytes32 m3;
    4980
            bytes32 m4;
    4981
            bytes32 m5;
    4982
            bytes32 m6;
    4983
            /// @solidity memory-safe-assembly
    4984
            assembly {
    4985
                function writeString(pos, w) {
    4986
                    let length := 0
    4987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    4988
                    mstore(pos, length)
    4989
                    let shift := sub(256, shl(3, length))
    4990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    4991
                }
    4992
                m0 := mload(0x00)
    4993
                m1 := mload(0x20)
    4994
                m2 := mload(0x40)
    4995
                m3 := mload(0x60)
    4996
                m4 := mload(0x80)
    4997
                m5 := mload(0xa0)
    4998
                m6 := mload(0xc0)
    4999
                // Selector of `log(address,string,bool,address)`.
    5000
                mstore(0x00, 0x205871c2)
    5001
                mstore(0x20, p0)
    5002
                mstore(0x40, 0x80)
    5003
                mstore(0x60, p2)
    5004
                mstore(0x80, p3)
    5005
                writeString(0xa0, p1)
    5006
            }
    5007
            _sendLogPayload(0x1c, 0xc4);
    5008
            /// @solidity memory-safe-assembly
    5009
            assembly {
    5010
                mstore(0x00, m0)
    5011
                mstore(0x20, m1)
    5012
                mstore(0x40, m2)
    5013
                mstore(0x60, m3)
    5014
                mstore(0x80, m4)
    5015
                mstore(0xa0, m5)
    5016
                mstore(0xc0, m6)
    5017
            }
    5018
        }
    5019
    5020
        function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {
    5021
            bytes32 m0;
    5022
            bytes32 m1;
    5023
            bytes32 m2;
    5024
            bytes32 m3;
    5025
            bytes32 m4;
    5026
            bytes32 m5;
    5027
            bytes32 m6;
    5028
            /// @solidity memory-safe-assembly
    5029
            assembly {
    5030
                function writeString(pos, w) {
    5031
                    let length := 0
    5032
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5033
                    mstore(pos, length)
    5034
                    let shift := sub(256, shl(3, length))
    5035
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5036
                }
    5037
                m0 := mload(0x00)
    5038
                m1 := mload(0x20)
    5039
                m2 := mload(0x40)
    5040
                m3 := mload(0x60)
    5041
                m4 := mload(0x80)
    5042
                m5 := mload(0xa0)
    5043
                m6 := mload(0xc0)
    5044
                // Selector of `log(address,string,bool,bool)`.
    5045
                mstore(0x00, 0x5f1d5c9f)
    5046
                mstore(0x20, p0)
    5047
                mstore(0x40, 0x80)
    5048
                mstore(0x60, p2)
    5049
                mstore(0x80, p3)
    5050
                writeString(0xa0, p1)
    5051
            }
    5052
            _sendLogPayload(0x1c, 0xc4);
    5053
            /// @solidity memory-safe-assembly
    5054
            assembly {
    5055
                mstore(0x00, m0)
    5056
                mstore(0x20, m1)
    5057
                mstore(0x40, m2)
    5058
                mstore(0x60, m3)
    5059
                mstore(0x80, m4)
    5060
                mstore(0xa0, m5)
    5061
                mstore(0xc0, m6)
    5062
            }
    5063
        }
    5064
    5065
        function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    5066
            bytes32 m0;
    5067
            bytes32 m1;
    5068
            bytes32 m2;
    5069
            bytes32 m3;
    5070
            bytes32 m4;
    5071
            bytes32 m5;
    5072
            bytes32 m6;
    5073
            /// @solidity memory-safe-assembly
    5074
            assembly {
    5075
                function writeString(pos, w) {
    5076
                    let length := 0
    5077
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5078
                    mstore(pos, length)
    5079
                    let shift := sub(256, shl(3, length))
    5080
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5081
                }
    5082
                m0 := mload(0x00)
    5083
                m1 := mload(0x20)
    5084
                m2 := mload(0x40)
    5085
                m3 := mload(0x60)
    5086
                m4 := mload(0x80)
    5087
                m5 := mload(0xa0)
    5088
                m6 := mload(0xc0)
    5089
                // Selector of `log(address,string,bool,uint256)`.
    5090
                mstore(0x00, 0x515e38b6)
    5091
                mstore(0x20, p0)
    5092
                mstore(0x40, 0x80)
    5093
                mstore(0x60, p2)
    5094
                mstore(0x80, p3)
    5095
                writeString(0xa0, p1)
    5096
            }
    5097
            _sendLogPayload(0x1c, 0xc4);
    5098
            /// @solidity memory-safe-assembly
    5099
            assembly {
    5100
                mstore(0x00, m0)
    5101
                mstore(0x20, m1)
    5102
                mstore(0x40, m2)
    5103
                mstore(0x60, m3)
    5104
                mstore(0x80, m4)
    5105
                mstore(0xa0, m5)
    5106
                mstore(0xc0, m6)
    5107
            }
    5108
        }
    5109
    5110
        function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    5111
            bytes32 m0;
    5112
            bytes32 m1;
    5113
            bytes32 m2;
    5114
            bytes32 m3;
    5115
            bytes32 m4;
    5116
            bytes32 m5;
    5117
            bytes32 m6;
    5118
            bytes32 m7;
    5119
            bytes32 m8;
    5120
            /// @solidity memory-safe-assembly
    5121
            assembly {
    5122
                function writeString(pos, w) {
    5123
                    let length := 0
    5124
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5125
                    mstore(pos, length)
    5126
                    let shift := sub(256, shl(3, length))
    5127
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5128
                }
    5129
                m0 := mload(0x00)
    5130
                m1 := mload(0x20)
    5131
                m2 := mload(0x40)
    5132
                m3 := mload(0x60)
    5133
                m4 := mload(0x80)
    5134
                m5 := mload(0xa0)
    5135
                m6 := mload(0xc0)
    5136
                m7 := mload(0xe0)
    5137
                m8 := mload(0x100)
    5138
                // Selector of `log(address,string,bool,string)`.
    5139
                mstore(0x00, 0xbc0b61fe)
    5140
                mstore(0x20, p0)
    5141
                mstore(0x40, 0x80)
    5142
                mstore(0x60, p2)
    5143
                mstore(0x80, 0xc0)
    5144
                writeString(0xa0, p1)
    5145
                writeString(0xe0, p3)
    5146
            }
    5147
            _sendLogPayload(0x1c, 0x104);
    5148
            /// @solidity memory-safe-assembly
    5149
            assembly {
    5150
                mstore(0x00, m0)
    5151
                mstore(0x20, m1)
    5152
                mstore(0x40, m2)
    5153
                mstore(0x60, m3)
    5154
                mstore(0x80, m4)
    5155
                mstore(0xa0, m5)
    5156
                mstore(0xc0, m6)
    5157
                mstore(0xe0, m7)
    5158
                mstore(0x100, m8)
    5159
            }
    5160
        }
    5161
    5162
        function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {
    5163
            bytes32 m0;
    5164
            bytes32 m1;
    5165
            bytes32 m2;
    5166
            bytes32 m3;
    5167
            bytes32 m4;
    5168
            bytes32 m5;
    5169
            bytes32 m6;
    5170
            /// @solidity memory-safe-assembly
    5171
            assembly {
    5172
                function writeString(pos, w) {
    5173
                    let length := 0
    5174
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5175
                    mstore(pos, length)
    5176
                    let shift := sub(256, shl(3, length))
    5177
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5178
                }
    5179
                m0 := mload(0x00)
    5180
                m1 := mload(0x20)
    5181
                m2 := mload(0x40)
    5182
                m3 := mload(0x60)
    5183
                m4 := mload(0x80)
    5184
                m5 := mload(0xa0)
    5185
                m6 := mload(0xc0)
    5186
                // Selector of `log(address,string,uint256,address)`.
    5187
                mstore(0x00, 0x63183678)
    5188
                mstore(0x20, p0)
    5189
                mstore(0x40, 0x80)
    5190
                mstore(0x60, p2)
    5191
                mstore(0x80, p3)
    5192
                writeString(0xa0, p1)
    5193
            }
    5194
            _sendLogPayload(0x1c, 0xc4);
    5195
            /// @solidity memory-safe-assembly
    5196
            assembly {
    5197
                mstore(0x00, m0)
    5198
                mstore(0x20, m1)
    5199
                mstore(0x40, m2)
    5200
                mstore(0x60, m3)
    5201
                mstore(0x80, m4)
    5202
                mstore(0xa0, m5)
    5203
                mstore(0xc0, m6)
    5204
            }
    5205
        }
    5206
    5207
        function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    5208
            bytes32 m0;
    5209
            bytes32 m1;
    5210
            bytes32 m2;
    5211
            bytes32 m3;
    5212
            bytes32 m4;
    5213
            bytes32 m5;
    5214
            bytes32 m6;
    5215
            /// @solidity memory-safe-assembly
    5216
            assembly {
    5217
                function writeString(pos, w) {
    5218
                    let length := 0
    5219
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5220
                    mstore(pos, length)
    5221
                    let shift := sub(256, shl(3, length))
    5222
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5223
                }
    5224
                m0 := mload(0x00)
    5225
                m1 := mload(0x20)
    5226
                m2 := mload(0x40)
    5227
                m3 := mload(0x60)
    5228
                m4 := mload(0x80)
    5229
                m5 := mload(0xa0)
    5230
                m6 := mload(0xc0)
    5231
                // Selector of `log(address,string,uint256,bool)`.
    5232
                mstore(0x00, 0x0ef7e050)
    5233
                mstore(0x20, p0)
    5234
                mstore(0x40, 0x80)
    5235
                mstore(0x60, p2)
    5236
                mstore(0x80, p3)
    5237
                writeString(0xa0, p1)
    5238
            }
    5239
            _sendLogPayload(0x1c, 0xc4);
    5240
            /// @solidity memory-safe-assembly
    5241
            assembly {
    5242
                mstore(0x00, m0)
    5243
                mstore(0x20, m1)
    5244
                mstore(0x40, m2)
    5245
                mstore(0x60, m3)
    5246
                mstore(0x80, m4)
    5247
                mstore(0xa0, m5)
    5248
                mstore(0xc0, m6)
    5249
            }
    5250
        }
    5251
    5252
        function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    5253
            bytes32 m0;
    5254
            bytes32 m1;
    5255
            bytes32 m2;
    5256
            bytes32 m3;
    5257
            bytes32 m4;
    5258
            bytes32 m5;
    5259
            bytes32 m6;
    5260
            /// @solidity memory-safe-assembly
    5261
            assembly {
    5262
                function writeString(pos, w) {
    5263
                    let length := 0
    5264
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5265
                    mstore(pos, length)
    5266
                    let shift := sub(256, shl(3, length))
    5267
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5268
                }
    5269
                m0 := mload(0x00)
    5270
                m1 := mload(0x20)
    5271
                m2 := mload(0x40)
    5272
                m3 := mload(0x60)
    5273
                m4 := mload(0x80)
    5274
                m5 := mload(0xa0)
    5275
                m6 := mload(0xc0)
    5276
                // Selector of `log(address,string,uint256,uint256)`.
    5277
                mstore(0x00, 0x1dc8e1b8)
    5278
                mstore(0x20, p0)
    5279
                mstore(0x40, 0x80)
    5280
                mstore(0x60, p2)
    5281
                mstore(0x80, p3)
    5282
                writeString(0xa0, p1)
    5283
            }
    5284
            _sendLogPayload(0x1c, 0xc4);
    5285
            /// @solidity memory-safe-assembly
    5286
            assembly {
    5287
                mstore(0x00, m0)
    5288
                mstore(0x20, m1)
    5289
                mstore(0x40, m2)
    5290
                mstore(0x60, m3)
    5291
                mstore(0x80, m4)
    5292
                mstore(0xa0, m5)
    5293
                mstore(0xc0, m6)
    5294
            }
    5295
        }
    5296
    5297
        function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    5298
            bytes32 m0;
    5299
            bytes32 m1;
    5300
            bytes32 m2;
    5301
            bytes32 m3;
    5302
            bytes32 m4;
    5303
            bytes32 m5;
    5304
            bytes32 m6;
    5305
            bytes32 m7;
    5306
            bytes32 m8;
    5307
            /// @solidity memory-safe-assembly
    5308
            assembly {
    5309
                function writeString(pos, w) {
    5310
                    let length := 0
    5311
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5312
                    mstore(pos, length)
    5313
                    let shift := sub(256, shl(3, length))
    5314
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5315
                }
    5316
                m0 := mload(0x00)
    5317
                m1 := mload(0x20)
    5318
                m2 := mload(0x40)
    5319
                m3 := mload(0x60)
    5320
                m4 := mload(0x80)
    5321
                m5 := mload(0xa0)
    5322
                m6 := mload(0xc0)
    5323
                m7 := mload(0xe0)
    5324
                m8 := mload(0x100)
    5325
                // Selector of `log(address,string,uint256,string)`.
    5326
                mstore(0x00, 0x448830a8)
    5327
                mstore(0x20, p0)
    5328
                mstore(0x40, 0x80)
    5329
                mstore(0x60, p2)
    5330
                mstore(0x80, 0xc0)
    5331
                writeString(0xa0, p1)
    5332
                writeString(0xe0, p3)
    5333
            }
    5334
            _sendLogPayload(0x1c, 0x104);
    5335
            /// @solidity memory-safe-assembly
    5336
            assembly {
    5337
                mstore(0x00, m0)
    5338
                mstore(0x20, m1)
    5339
                mstore(0x40, m2)
    5340
                mstore(0x60, m3)
    5341
                mstore(0x80, m4)
    5342
                mstore(0xa0, m5)
    5343
                mstore(0xc0, m6)
    5344
                mstore(0xe0, m7)
    5345
                mstore(0x100, m8)
    5346
            }
    5347
        }
    5348
    5349
        function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    5350
            bytes32 m0;
    5351
            bytes32 m1;
    5352
            bytes32 m2;
    5353
            bytes32 m3;
    5354
            bytes32 m4;
    5355
            bytes32 m5;
    5356
            bytes32 m6;
    5357
            bytes32 m7;
    5358
            bytes32 m8;
    5359
            /// @solidity memory-safe-assembly
    5360
            assembly {
    5361
                function writeString(pos, w) {
    5362
                    let length := 0
    5363
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5364
                    mstore(pos, length)
    5365
                    let shift := sub(256, shl(3, length))
    5366
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5367
                }
    5368
                m0 := mload(0x00)
    5369
                m1 := mload(0x20)
    5370
                m2 := mload(0x40)
    5371
                m3 := mload(0x60)
    5372
                m4 := mload(0x80)
    5373
                m5 := mload(0xa0)
    5374
                m6 := mload(0xc0)
    5375
                m7 := mload(0xe0)
    5376
                m8 := mload(0x100)
    5377
                // Selector of `log(address,string,string,address)`.
    5378
                mstore(0x00, 0xa04e2f87)
    5379
                mstore(0x20, p0)
    5380
                mstore(0x40, 0x80)
    5381
                mstore(0x60, 0xc0)
    5382
                mstore(0x80, p3)
    5383
                writeString(0xa0, p1)
    5384
                writeString(0xe0, p2)
    5385
            }
    5386
            _sendLogPayload(0x1c, 0x104);
    5387
            /// @solidity memory-safe-assembly
    5388
            assembly {
    5389
                mstore(0x00, m0)
    5390
                mstore(0x20, m1)
    5391
                mstore(0x40, m2)
    5392
                mstore(0x60, m3)
    5393
                mstore(0x80, m4)
    5394
                mstore(0xa0, m5)
    5395
                mstore(0xc0, m6)
    5396
                mstore(0xe0, m7)
    5397
                mstore(0x100, m8)
    5398
            }
    5399
        }
    5400
    5401
        function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    5402
            bytes32 m0;
    5403
            bytes32 m1;
    5404
            bytes32 m2;
    5405
            bytes32 m3;
    5406
            bytes32 m4;
    5407
            bytes32 m5;
    5408
            bytes32 m6;
    5409
            bytes32 m7;
    5410
            bytes32 m8;
    5411
            /// @solidity memory-safe-assembly
    5412
            assembly {
    5413
                function writeString(pos, w) {
    5414
                    let length := 0
    5415
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5416
                    mstore(pos, length)
    5417
                    let shift := sub(256, shl(3, length))
    5418
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5419
                }
    5420
                m0 := mload(0x00)
    5421
                m1 := mload(0x20)
    5422
                m2 := mload(0x40)
    5423
                m3 := mload(0x60)
    5424
                m4 := mload(0x80)
    5425
                m5 := mload(0xa0)
    5426
                m6 := mload(0xc0)
    5427
                m7 := mload(0xe0)
    5428
                m8 := mload(0x100)
    5429
                // Selector of `log(address,string,string,bool)`.
    5430
                mstore(0x00, 0x35a5071f)
    5431
                mstore(0x20, p0)
    5432
                mstore(0x40, 0x80)
    5433
                mstore(0x60, 0xc0)
    5434
                mstore(0x80, p3)
    5435
                writeString(0xa0, p1)
    5436
                writeString(0xe0, p2)
    5437
            }
    5438
            _sendLogPayload(0x1c, 0x104);
    5439
            /// @solidity memory-safe-assembly
    5440
            assembly {
    5441
                mstore(0x00, m0)
    5442
                mstore(0x20, m1)
    5443
                mstore(0x40, m2)
    5444
                mstore(0x60, m3)
    5445
                mstore(0x80, m4)
    5446
                mstore(0xa0, m5)
    5447
                mstore(0xc0, m6)
    5448
                mstore(0xe0, m7)
    5449
                mstore(0x100, m8)
    5450
            }
    5451
        }
    5452
    5453
        function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    5454
            bytes32 m0;
    5455
            bytes32 m1;
    5456
            bytes32 m2;
    5457
            bytes32 m3;
    5458
            bytes32 m4;
    5459
            bytes32 m5;
    5460
            bytes32 m6;
    5461
            bytes32 m7;
    5462
            bytes32 m8;
    5463
            /// @solidity memory-safe-assembly
    5464
            assembly {
    5465
                function writeString(pos, w) {
    5466
                    let length := 0
    5467
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5468
                    mstore(pos, length)
    5469
                    let shift := sub(256, shl(3, length))
    5470
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5471
                }
    5472
                m0 := mload(0x00)
    5473
                m1 := mload(0x20)
    5474
                m2 := mload(0x40)
    5475
                m3 := mload(0x60)
    5476
                m4 := mload(0x80)
    5477
                m5 := mload(0xa0)
    5478
                m6 := mload(0xc0)
    5479
                m7 := mload(0xe0)
    5480
                m8 := mload(0x100)
    5481
                // Selector of `log(address,string,string,uint256)`.
    5482
                mstore(0x00, 0x159f8927)
    5483
                mstore(0x20, p0)
    5484
                mstore(0x40, 0x80)
    5485
                mstore(0x60, 0xc0)
    5486
                mstore(0x80, p3)
    5487
                writeString(0xa0, p1)
    5488
                writeString(0xe0, p2)
    5489
            }
    5490
            _sendLogPayload(0x1c, 0x104);
    5491
            /// @solidity memory-safe-assembly
    5492
            assembly {
    5493
                mstore(0x00, m0)
    5494
                mstore(0x20, m1)
    5495
                mstore(0x40, m2)
    5496
                mstore(0x60, m3)
    5497
                mstore(0x80, m4)
    5498
                mstore(0xa0, m5)
    5499
                mstore(0xc0, m6)
    5500
                mstore(0xe0, m7)
    5501
                mstore(0x100, m8)
    5502
            }
    5503
        }
    5504
    5505
        function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    5506
            bytes32 m0;
    5507
            bytes32 m1;
    5508
            bytes32 m2;
    5509
            bytes32 m3;
    5510
            bytes32 m4;
    5511
            bytes32 m5;
    5512
            bytes32 m6;
    5513
            bytes32 m7;
    5514
            bytes32 m8;
    5515
            bytes32 m9;
    5516
            bytes32 m10;
    5517
            /// @solidity memory-safe-assembly
    5518
            assembly {
    5519
                function writeString(pos, w) {
    5520
                    let length := 0
    5521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5522
                    mstore(pos, length)
    5523
                    let shift := sub(256, shl(3, length))
    5524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5525
                }
    5526
                m0 := mload(0x00)
    5527
                m1 := mload(0x20)
    5528
                m2 := mload(0x40)
    5529
                m3 := mload(0x60)
    5530
                m4 := mload(0x80)
    5531
                m5 := mload(0xa0)
    5532
                m6 := mload(0xc0)
    5533
                m7 := mload(0xe0)
    5534
                m8 := mload(0x100)
    5535
                m9 := mload(0x120)
    5536
                m10 := mload(0x140)
    5537
                // Selector of `log(address,string,string,string)`.
    5538
                mstore(0x00, 0x5d02c50b)
    5539
                mstore(0x20, p0)
    5540
                mstore(0x40, 0x80)
    5541
                mstore(0x60, 0xc0)
    5542
                mstore(0x80, 0x100)
    5543
                writeString(0xa0, p1)
    5544
                writeString(0xe0, p2)
    5545
                writeString(0x120, p3)
    5546
            }
    5547
            _sendLogPayload(0x1c, 0x144);
    5548
            /// @solidity memory-safe-assembly
    5549
            assembly {
    5550
                mstore(0x00, m0)
    5551
                mstore(0x20, m1)
    5552
                mstore(0x40, m2)
    5553
                mstore(0x60, m3)
    5554
                mstore(0x80, m4)
    5555
                mstore(0xa0, m5)
    5556
                mstore(0xc0, m6)
    5557
                mstore(0xe0, m7)
    5558
                mstore(0x100, m8)
    5559
                mstore(0x120, m9)
    5560
                mstore(0x140, m10)
    5561
            }
    5562
        }
    5563
    5564
        function log(bool p0, address p1, address p2, address p3) internal pure {
    5565
            bytes32 m0;
    5566
            bytes32 m1;
    5567
            bytes32 m2;
    5568
            bytes32 m3;
    5569
            bytes32 m4;
    5570
            /// @solidity memory-safe-assembly
    5571
            assembly {
    5572
                m0 := mload(0x00)
    5573
                m1 := mload(0x20)
    5574
                m2 := mload(0x40)
    5575
                m3 := mload(0x60)
    5576
                m4 := mload(0x80)
    5577
                // Selector of `log(bool,address,address,address)`.
    5578
                mstore(0x00, 0x1d14d001)
    5579
                mstore(0x20, p0)
    5580
                mstore(0x40, p1)
    5581
                mstore(0x60, p2)
    5582
                mstore(0x80, p3)
    5583
            }
    5584
            _sendLogPayload(0x1c, 0x84);
    5585
            /// @solidity memory-safe-assembly
    5586
            assembly {
    5587
                mstore(0x00, m0)
    5588
                mstore(0x20, m1)
    5589
                mstore(0x40, m2)
    5590
                mstore(0x60, m3)
    5591
                mstore(0x80, m4)
    5592
            }
    5593
        }
    5594
    5595
        function log(bool p0, address p1, address p2, bool p3) internal pure {
    5596
            bytes32 m0;
    5597
            bytes32 m1;
    5598
            bytes32 m2;
    5599
            bytes32 m3;
    5600
            bytes32 m4;
    5601
            /// @solidity memory-safe-assembly
    5602
            assembly {
    5603
                m0 := mload(0x00)
    5604
                m1 := mload(0x20)
    5605
                m2 := mload(0x40)
    5606
                m3 := mload(0x60)
    5607
                m4 := mload(0x80)
    5608
                // Selector of `log(bool,address,address,bool)`.
    5609
                mstore(0x00, 0x46600be0)
    5610
                mstore(0x20, p0)
    5611
                mstore(0x40, p1)
    5612
                mstore(0x60, p2)
    5613
                mstore(0x80, p3)
    5614
            }
    5615
            _sendLogPayload(0x1c, 0x84);
    5616
            /// @solidity memory-safe-assembly
    5617
            assembly {
    5618
                mstore(0x00, m0)
    5619
                mstore(0x20, m1)
    5620
                mstore(0x40, m2)
    5621
                mstore(0x60, m3)
    5622
                mstore(0x80, m4)
    5623
            }
    5624
        }
    5625
    5626
        function log(bool p0, address p1, address p2, uint256 p3) internal pure {
    5627
            bytes32 m0;
    5628
            bytes32 m1;
    5629
            bytes32 m2;
    5630
            bytes32 m3;
    5631
            bytes32 m4;
    5632
            /// @solidity memory-safe-assembly
    5633
            assembly {
    5634
                m0 := mload(0x00)
    5635
                m1 := mload(0x20)
    5636
                m2 := mload(0x40)
    5637
                m3 := mload(0x60)
    5638
                m4 := mload(0x80)
    5639
                // Selector of `log(bool,address,address,uint256)`.
    5640
                mstore(0x00, 0x0c66d1be)
    5641
                mstore(0x20, p0)
    5642
                mstore(0x40, p1)
    5643
                mstore(0x60, p2)
    5644
                mstore(0x80, p3)
    5645
            }
    5646
            _sendLogPayload(0x1c, 0x84);
    5647
            /// @solidity memory-safe-assembly
    5648
            assembly {
    5649
                mstore(0x00, m0)
    5650
                mstore(0x20, m1)
    5651
                mstore(0x40, m2)
    5652
                mstore(0x60, m3)
    5653
                mstore(0x80, m4)
    5654
            }
    5655
        }
    5656
    5657
        function log(bool p0, address p1, address p2, bytes32 p3) internal pure {
    5658
            bytes32 m0;
    5659
            bytes32 m1;
    5660
            bytes32 m2;
    5661
            bytes32 m3;
    5662
            bytes32 m4;
    5663
            bytes32 m5;
    5664
            bytes32 m6;
    5665
            /// @solidity memory-safe-assembly
    5666
            assembly {
    5667
                function writeString(pos, w) {
    5668
                    let length := 0
    5669
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5670
                    mstore(pos, length)
    5671
                    let shift := sub(256, shl(3, length))
    5672
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5673
                }
    5674
                m0 := mload(0x00)
    5675
                m1 := mload(0x20)
    5676
                m2 := mload(0x40)
    5677
                m3 := mload(0x60)
    5678
                m4 := mload(0x80)
    5679
                m5 := mload(0xa0)
    5680
                m6 := mload(0xc0)
    5681
                // Selector of `log(bool,address,address,string)`.
    5682
                mstore(0x00, 0xd812a167)
    5683
                mstore(0x20, p0)
    5684
                mstore(0x40, p1)
    5685
                mstore(0x60, p2)
    5686
                mstore(0x80, 0x80)
    5687
                writeString(0xa0, p3)
    5688
            }
    5689
            _sendLogPayload(0x1c, 0xc4);
    5690
            /// @solidity memory-safe-assembly
    5691
            assembly {
    5692
                mstore(0x00, m0)
    5693
                mstore(0x20, m1)
    5694
                mstore(0x40, m2)
    5695
                mstore(0x60, m3)
    5696
                mstore(0x80, m4)
    5697
                mstore(0xa0, m5)
    5698
                mstore(0xc0, m6)
    5699
            }
    5700
        }
    5701
    5702
        function log(bool p0, address p1, bool p2, address p3) internal pure {
    5703
            bytes32 m0;
    5704
            bytes32 m1;
    5705
            bytes32 m2;
    5706
            bytes32 m3;
    5707
            bytes32 m4;
    5708
            /// @solidity memory-safe-assembly
    5709
            assembly {
    5710
                m0 := mload(0x00)
    5711
                m1 := mload(0x20)
    5712
                m2 := mload(0x40)
    5713
                m3 := mload(0x60)
    5714
                m4 := mload(0x80)
    5715
                // Selector of `log(bool,address,bool,address)`.
    5716
                mstore(0x00, 0x1c41a336)
    5717
                mstore(0x20, p0)
    5718
                mstore(0x40, p1)
    5719
                mstore(0x60, p2)
    5720
                mstore(0x80, p3)
    5721
            }
    5722
            _sendLogPayload(0x1c, 0x84);
    5723
            /// @solidity memory-safe-assembly
    5724
            assembly {
    5725
                mstore(0x00, m0)
    5726
                mstore(0x20, m1)
    5727
                mstore(0x40, m2)
    5728
                mstore(0x60, m3)
    5729
                mstore(0x80, m4)
    5730
            }
    5731
        }
    5732
    5733
        function log(bool p0, address p1, bool p2, bool p3) internal pure {
    5734
            bytes32 m0;
    5735
            bytes32 m1;
    5736
            bytes32 m2;
    5737
            bytes32 m3;
    5738
            bytes32 m4;
    5739
            /// @solidity memory-safe-assembly
    5740
            assembly {
    5741
                m0 := mload(0x00)
    5742
                m1 := mload(0x20)
    5743
                m2 := mload(0x40)
    5744
                m3 := mload(0x60)
    5745
                m4 := mload(0x80)
    5746
                // Selector of `log(bool,address,bool,bool)`.
    5747
                mstore(0x00, 0x6a9c478b)
    5748
                mstore(0x20, p0)
    5749
                mstore(0x40, p1)
    5750
                mstore(0x60, p2)
    5751
                mstore(0x80, p3)
    5752
            }
    5753
            _sendLogPayload(0x1c, 0x84);
    5754
            /// @solidity memory-safe-assembly
    5755
            assembly {
    5756
                mstore(0x00, m0)
    5757
                mstore(0x20, m1)
    5758
                mstore(0x40, m2)
    5759
                mstore(0x60, m3)
    5760
                mstore(0x80, m4)
    5761
            }
    5762
        }
    5763
    5764
        function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
    5765
            bytes32 m0;
    5766
            bytes32 m1;
    5767
            bytes32 m2;
    5768
            bytes32 m3;
    5769
            bytes32 m4;
    5770
            /// @solidity memory-safe-assembly
    5771
            assembly {
    5772
                m0 := mload(0x00)
    5773
                m1 := mload(0x20)
    5774
                m2 := mload(0x40)
    5775
                m3 := mload(0x60)
    5776
                m4 := mload(0x80)
    5777
                // Selector of `log(bool,address,bool,uint256)`.
    5778
                mstore(0x00, 0x07831502)
    5779
                mstore(0x20, p0)
    5780
                mstore(0x40, p1)
    5781
                mstore(0x60, p2)
    5782
                mstore(0x80, p3)
    5783
            }
    5784
            _sendLogPayload(0x1c, 0x84);
    5785
            /// @solidity memory-safe-assembly
    5786
            assembly {
    5787
                mstore(0x00, m0)
    5788
                mstore(0x20, m1)
    5789
                mstore(0x40, m2)
    5790
                mstore(0x60, m3)
    5791
                mstore(0x80, m4)
    5792
            }
    5793
        }
    5794
    5795
        function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {
    5796
            bytes32 m0;
    5797
            bytes32 m1;
    5798
            bytes32 m2;
    5799
            bytes32 m3;
    5800
            bytes32 m4;
    5801
            bytes32 m5;
    5802
            bytes32 m6;
    5803
            /// @solidity memory-safe-assembly
    5804
            assembly {
    5805
                function writeString(pos, w) {
    5806
                    let length := 0
    5807
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5808
                    mstore(pos, length)
    5809
                    let shift := sub(256, shl(3, length))
    5810
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5811
                }
    5812
                m0 := mload(0x00)
    5813
                m1 := mload(0x20)
    5814
                m2 := mload(0x40)
    5815
                m3 := mload(0x60)
    5816
                m4 := mload(0x80)
    5817
                m5 := mload(0xa0)
    5818
                m6 := mload(0xc0)
    5819
                // Selector of `log(bool,address,bool,string)`.
    5820
                mstore(0x00, 0x4a66cb34)
    5821
                mstore(0x20, p0)
    5822
                mstore(0x40, p1)
    5823
                mstore(0x60, p2)
    5824
                mstore(0x80, 0x80)
    5825
                writeString(0xa0, p3)
    5826
            }
    5827
            _sendLogPayload(0x1c, 0xc4);
    5828
            /// @solidity memory-safe-assembly
    5829
            assembly {
    5830
                mstore(0x00, m0)
    5831
                mstore(0x20, m1)
    5832
                mstore(0x40, m2)
    5833
                mstore(0x60, m3)
    5834
                mstore(0x80, m4)
    5835
                mstore(0xa0, m5)
    5836
                mstore(0xc0, m6)
    5837
            }
    5838
        }
    5839
    5840
        function log(bool p0, address p1, uint256 p2, address p3) internal pure {
    5841
            bytes32 m0;
    5842
            bytes32 m1;
    5843
            bytes32 m2;
    5844
            bytes32 m3;
    5845
            bytes32 m4;
    5846
            /// @solidity memory-safe-assembly
    5847
            assembly {
    5848
                m0 := mload(0x00)
    5849
                m1 := mload(0x20)
    5850
                m2 := mload(0x40)
    5851
                m3 := mload(0x60)
    5852
                m4 := mload(0x80)
    5853
                // Selector of `log(bool,address,uint256,address)`.
    5854
                mstore(0x00, 0x136b05dd)
    5855
                mstore(0x20, p0)
    5856
                mstore(0x40, p1)
    5857
                mstore(0x60, p2)
    5858
                mstore(0x80, p3)
    5859
            }
    5860
            _sendLogPayload(0x1c, 0x84);
    5861
            /// @solidity memory-safe-assembly
    5862
            assembly {
    5863
                mstore(0x00, m0)
    5864
                mstore(0x20, m1)
    5865
                mstore(0x40, m2)
    5866
                mstore(0x60, m3)
    5867
                mstore(0x80, m4)
    5868
            }
    5869
        }
    5870
    5871
        function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
    5872
            bytes32 m0;
    5873
            bytes32 m1;
    5874
            bytes32 m2;
    5875
            bytes32 m3;
    5876
            bytes32 m4;
    5877
            /// @solidity memory-safe-assembly
    5878
            assembly {
    5879
                m0 := mload(0x00)
    5880
                m1 := mload(0x20)
    5881
                m2 := mload(0x40)
    5882
                m3 := mload(0x60)
    5883
                m4 := mload(0x80)
    5884
                // Selector of `log(bool,address,uint256,bool)`.
    5885
                mstore(0x00, 0xd6019f1c)
    5886
                mstore(0x20, p0)
    5887
                mstore(0x40, p1)
    5888
                mstore(0x60, p2)
    5889
                mstore(0x80, p3)
    5890
            }
    5891
            _sendLogPayload(0x1c, 0x84);
    5892
            /// @solidity memory-safe-assembly
    5893
            assembly {
    5894
                mstore(0x00, m0)
    5895
                mstore(0x20, m1)
    5896
                mstore(0x40, m2)
    5897
                mstore(0x60, m3)
    5898
                mstore(0x80, m4)
    5899
            }
    5900
        }
    5901
    5902
        function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
    5903
            bytes32 m0;
    5904
            bytes32 m1;
    5905
            bytes32 m2;
    5906
            bytes32 m3;
    5907
            bytes32 m4;
    5908
            /// @solidity memory-safe-assembly
    5909
            assembly {
    5910
                m0 := mload(0x00)
    5911
                m1 := mload(0x20)
    5912
                m2 := mload(0x40)
    5913
                m3 := mload(0x60)
    5914
                m4 := mload(0x80)
    5915
                // Selector of `log(bool,address,uint256,uint256)`.
    5916
                mstore(0x00, 0x7bf181a1)
    5917
                mstore(0x20, p0)
    5918
                mstore(0x40, p1)
    5919
                mstore(0x60, p2)
    5920
                mstore(0x80, p3)
    5921
            }
    5922
            _sendLogPayload(0x1c, 0x84);
    5923
            /// @solidity memory-safe-assembly
    5924
            assembly {
    5925
                mstore(0x00, m0)
    5926
                mstore(0x20, m1)
    5927
                mstore(0x40, m2)
    5928
                mstore(0x60, m3)
    5929
                mstore(0x80, m4)
    5930
            }
    5931
        }
    5932
    5933
        function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {
    5934
            bytes32 m0;
    5935
            bytes32 m1;
    5936
            bytes32 m2;
    5937
            bytes32 m3;
    5938
            bytes32 m4;
    5939
            bytes32 m5;
    5940
            bytes32 m6;
    5941
            /// @solidity memory-safe-assembly
    5942
            assembly {
    5943
                function writeString(pos, w) {
    5944
                    let length := 0
    5945
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5946
                    mstore(pos, length)
    5947
                    let shift := sub(256, shl(3, length))
    5948
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5949
                }
    5950
                m0 := mload(0x00)
    5951
                m1 := mload(0x20)
    5952
                m2 := mload(0x40)
    5953
                m3 := mload(0x60)
    5954
                m4 := mload(0x80)
    5955
                m5 := mload(0xa0)
    5956
                m6 := mload(0xc0)
    5957
                // Selector of `log(bool,address,uint256,string)`.
    5958
                mstore(0x00, 0x51f09ff8)
    5959
                mstore(0x20, p0)
    5960
                mstore(0x40, p1)
    5961
                mstore(0x60, p2)
    5962
                mstore(0x80, 0x80)
    5963
                writeString(0xa0, p3)
    5964
            }
    5965
            _sendLogPayload(0x1c, 0xc4);
    5966
            /// @solidity memory-safe-assembly
    5967
            assembly {
    5968
                mstore(0x00, m0)
    5969
                mstore(0x20, m1)
    5970
                mstore(0x40, m2)
    5971
                mstore(0x60, m3)
    5972
                mstore(0x80, m4)
    5973
                mstore(0xa0, m5)
    5974
                mstore(0xc0, m6)
    5975
            }
    5976
        }
    5977
    5978
        function log(bool p0, address p1, bytes32 p2, address p3) internal pure {
    5979
            bytes32 m0;
    5980
            bytes32 m1;
    5981
            bytes32 m2;
    5982
            bytes32 m3;
    5983
            bytes32 m4;
    5984
            bytes32 m5;
    5985
            bytes32 m6;
    5986
            /// @solidity memory-safe-assembly
    5987
            assembly {
    5988
                function writeString(pos, w) {
    5989
                    let length := 0
    5990
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    5991
                    mstore(pos, length)
    5992
                    let shift := sub(256, shl(3, length))
    5993
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    5994
                }
    5995
                m0 := mload(0x00)
    5996
                m1 := mload(0x20)
    5997
                m2 := mload(0x40)
    5998
                m3 := mload(0x60)
    5999
                m4 := mload(0x80)
    6000
                m5 := mload(0xa0)
    6001
                m6 := mload(0xc0)
    6002
                // Selector of `log(bool,address,string,address)`.
    6003
                mstore(0x00, 0x6f7c603e)
    6004
                mstore(0x20, p0)
    6005
                mstore(0x40, p1)
    6006
                mstore(0x60, 0x80)
    6007
                mstore(0x80, p3)
    6008
                writeString(0xa0, p2)
    6009
            }
    6010
            _sendLogPayload(0x1c, 0xc4);
    6011
            /// @solidity memory-safe-assembly
    6012
            assembly {
    6013
                mstore(0x00, m0)
    6014
                mstore(0x20, m1)
    6015
                mstore(0x40, m2)
    6016
                mstore(0x60, m3)
    6017
                mstore(0x80, m4)
    6018
                mstore(0xa0, m5)
    6019
                mstore(0xc0, m6)
    6020
            }
    6021
        }
    6022
    6023
        function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {
    6024
            bytes32 m0;
    6025
            bytes32 m1;
    6026
            bytes32 m2;
    6027
            bytes32 m3;
    6028
            bytes32 m4;
    6029
            bytes32 m5;
    6030
            bytes32 m6;
    6031
            /// @solidity memory-safe-assembly
    6032
            assembly {
    6033
                function writeString(pos, w) {
    6034
                    let length := 0
    6035
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6036
                    mstore(pos, length)
    6037
                    let shift := sub(256, shl(3, length))
    6038
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6039
                }
    6040
                m0 := mload(0x00)
    6041
                m1 := mload(0x20)
    6042
                m2 := mload(0x40)
    6043
                m3 := mload(0x60)
    6044
                m4 := mload(0x80)
    6045
                m5 := mload(0xa0)
    6046
                m6 := mload(0xc0)
    6047
                // Selector of `log(bool,address,string,bool)`.
    6048
                mstore(0x00, 0xe2bfd60b)
    6049
                mstore(0x20, p0)
    6050
                mstore(0x40, p1)
    6051
                mstore(0x60, 0x80)
    6052
                mstore(0x80, p3)
    6053
                writeString(0xa0, p2)
    6054
            }
    6055
            _sendLogPayload(0x1c, 0xc4);
    6056
            /// @solidity memory-safe-assembly
    6057
            assembly {
    6058
                mstore(0x00, m0)
    6059
                mstore(0x20, m1)
    6060
                mstore(0x40, m2)
    6061
                mstore(0x60, m3)
    6062
                mstore(0x80, m4)
    6063
                mstore(0xa0, m5)
    6064
                mstore(0xc0, m6)
    6065
            }
    6066
        }
    6067
    6068
        function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {
    6069
            bytes32 m0;
    6070
            bytes32 m1;
    6071
            bytes32 m2;
    6072
            bytes32 m3;
    6073
            bytes32 m4;
    6074
            bytes32 m5;
    6075
            bytes32 m6;
    6076
            /// @solidity memory-safe-assembly
    6077
            assembly {
    6078
                function writeString(pos, w) {
    6079
                    let length := 0
    6080
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6081
                    mstore(pos, length)
    6082
                    let shift := sub(256, shl(3, length))
    6083
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6084
                }
    6085
                m0 := mload(0x00)
    6086
                m1 := mload(0x20)
    6087
                m2 := mload(0x40)
    6088
                m3 := mload(0x60)
    6089
                m4 := mload(0x80)
    6090
                m5 := mload(0xa0)
    6091
                m6 := mload(0xc0)
    6092
                // Selector of `log(bool,address,string,uint256)`.
    6093
                mstore(0x00, 0xc21f64c7)
    6094
                mstore(0x20, p0)
    6095
                mstore(0x40, p1)
    6096
                mstore(0x60, 0x80)
    6097
                mstore(0x80, p3)
    6098
                writeString(0xa0, p2)
    6099
            }
    6100
            _sendLogPayload(0x1c, 0xc4);
    6101
            /// @solidity memory-safe-assembly
    6102
            assembly {
    6103
                mstore(0x00, m0)
    6104
                mstore(0x20, m1)
    6105
                mstore(0x40, m2)
    6106
                mstore(0x60, m3)
    6107
                mstore(0x80, m4)
    6108
                mstore(0xa0, m5)
    6109
                mstore(0xc0, m6)
    6110
            }
    6111
        }
    6112
    6113
        function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    6114
            bytes32 m0;
    6115
            bytes32 m1;
    6116
            bytes32 m2;
    6117
            bytes32 m3;
    6118
            bytes32 m4;
    6119
            bytes32 m5;
    6120
            bytes32 m6;
    6121
            bytes32 m7;
    6122
            bytes32 m8;
    6123
            /// @solidity memory-safe-assembly
    6124
            assembly {
    6125
                function writeString(pos, w) {
    6126
                    let length := 0
    6127
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6128
                    mstore(pos, length)
    6129
                    let shift := sub(256, shl(3, length))
    6130
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6131
                }
    6132
                m0 := mload(0x00)
    6133
                m1 := mload(0x20)
    6134
                m2 := mload(0x40)
    6135
                m3 := mload(0x60)
    6136
                m4 := mload(0x80)
    6137
                m5 := mload(0xa0)
    6138
                m6 := mload(0xc0)
    6139
                m7 := mload(0xe0)
    6140
                m8 := mload(0x100)
    6141
                // Selector of `log(bool,address,string,string)`.
    6142
                mstore(0x00, 0xa73c1db6)
    6143
                mstore(0x20, p0)
    6144
                mstore(0x40, p1)
    6145
                mstore(0x60, 0x80)
    6146
                mstore(0x80, 0xc0)
    6147
                writeString(0xa0, p2)
    6148
                writeString(0xe0, p3)
    6149
            }
    6150
            _sendLogPayload(0x1c, 0x104);
    6151
            /// @solidity memory-safe-assembly
    6152
            assembly {
    6153
                mstore(0x00, m0)
    6154
                mstore(0x20, m1)
    6155
                mstore(0x40, m2)
    6156
                mstore(0x60, m3)
    6157
                mstore(0x80, m4)
    6158
                mstore(0xa0, m5)
    6159
                mstore(0xc0, m6)
    6160
                mstore(0xe0, m7)
    6161
                mstore(0x100, m8)
    6162
            }
    6163
        }
    6164
    6165
        function log(bool p0, bool p1, address p2, address p3) internal pure {
    6166
            bytes32 m0;
    6167
            bytes32 m1;
    6168
            bytes32 m2;
    6169
            bytes32 m3;
    6170
            bytes32 m4;
    6171
            /// @solidity memory-safe-assembly
    6172
            assembly {
    6173
                m0 := mload(0x00)
    6174
                m1 := mload(0x20)
    6175
                m2 := mload(0x40)
    6176
                m3 := mload(0x60)
    6177
                m4 := mload(0x80)
    6178
                // Selector of `log(bool,bool,address,address)`.
    6179
                mstore(0x00, 0xf4880ea4)
    6180
                mstore(0x20, p0)
    6181
                mstore(0x40, p1)
    6182
                mstore(0x60, p2)
    6183
                mstore(0x80, p3)
    6184
            }
    6185
            _sendLogPayload(0x1c, 0x84);
    6186
            /// @solidity memory-safe-assembly
    6187
            assembly {
    6188
                mstore(0x00, m0)
    6189
                mstore(0x20, m1)
    6190
                mstore(0x40, m2)
    6191
                mstore(0x60, m3)
    6192
                mstore(0x80, m4)
    6193
            }
    6194
        }
    6195
    6196
        function log(bool p0, bool p1, address p2, bool p3) internal pure {
    6197
            bytes32 m0;
    6198
            bytes32 m1;
    6199
            bytes32 m2;
    6200
            bytes32 m3;
    6201
            bytes32 m4;
    6202
            /// @solidity memory-safe-assembly
    6203
            assembly {
    6204
                m0 := mload(0x00)
    6205
                m1 := mload(0x20)
    6206
                m2 := mload(0x40)
    6207
                m3 := mload(0x60)
    6208
                m4 := mload(0x80)
    6209
                // Selector of `log(bool,bool,address,bool)`.
    6210
                mstore(0x00, 0xc0a302d8)
    6211
                mstore(0x20, p0)
    6212
                mstore(0x40, p1)
    6213
                mstore(0x60, p2)
    6214
                mstore(0x80, p3)
    6215
            }
    6216
            _sendLogPayload(0x1c, 0x84);
    6217
            /// @solidity memory-safe-assembly
    6218
            assembly {
    6219
                mstore(0x00, m0)
    6220
                mstore(0x20, m1)
    6221
                mstore(0x40, m2)
    6222
                mstore(0x60, m3)
    6223
                mstore(0x80, m4)
    6224
            }
    6225
        }
    6226
    6227
        function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
    6228
            bytes32 m0;
    6229
            bytes32 m1;
    6230
            bytes32 m2;
    6231
            bytes32 m3;
    6232
            bytes32 m4;
    6233
            /// @solidity memory-safe-assembly
    6234
            assembly {
    6235
                m0 := mload(0x00)
    6236
                m1 := mload(0x20)
    6237
                m2 := mload(0x40)
    6238
                m3 := mload(0x60)
    6239
                m4 := mload(0x80)
    6240
                // Selector of `log(bool,bool,address,uint256)`.
    6241
                mstore(0x00, 0x4c123d57)
    6242
                mstore(0x20, p0)
    6243
                mstore(0x40, p1)
    6244
                mstore(0x60, p2)
    6245
                mstore(0x80, p3)
    6246
            }
    6247
            _sendLogPayload(0x1c, 0x84);
    6248
            /// @solidity memory-safe-assembly
    6249
            assembly {
    6250
                mstore(0x00, m0)
    6251
                mstore(0x20, m1)
    6252
                mstore(0x40, m2)
    6253
                mstore(0x60, m3)
    6254
                mstore(0x80, m4)
    6255
            }
    6256
        }
    6257
    6258
        function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {
    6259
            bytes32 m0;
    6260
            bytes32 m1;
    6261
            bytes32 m2;
    6262
            bytes32 m3;
    6263
            bytes32 m4;
    6264
            bytes32 m5;
    6265
            bytes32 m6;
    6266
            /// @solidity memory-safe-assembly
    6267
            assembly {
    6268
                function writeString(pos, w) {
    6269
                    let length := 0
    6270
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6271
                    mstore(pos, length)
    6272
                    let shift := sub(256, shl(3, length))
    6273
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6274
                }
    6275
                m0 := mload(0x00)
    6276
                m1 := mload(0x20)
    6277
                m2 := mload(0x40)
    6278
                m3 := mload(0x60)
    6279
                m4 := mload(0x80)
    6280
                m5 := mload(0xa0)
    6281
                m6 := mload(0xc0)
    6282
                // Selector of `log(bool,bool,address,string)`.
    6283
                mstore(0x00, 0xa0a47963)
    6284
                mstore(0x20, p0)
    6285
                mstore(0x40, p1)
    6286
                mstore(0x60, p2)
    6287
                mstore(0x80, 0x80)
    6288
                writeString(0xa0, p3)
    6289
            }
    6290
            _sendLogPayload(0x1c, 0xc4);
    6291
            /// @solidity memory-safe-assembly
    6292
            assembly {
    6293
                mstore(0x00, m0)
    6294
                mstore(0x20, m1)
    6295
                mstore(0x40, m2)
    6296
                mstore(0x60, m3)
    6297
                mstore(0x80, m4)
    6298
                mstore(0xa0, m5)
    6299
                mstore(0xc0, m6)
    6300
            }
    6301
        }
    6302
    6303
        function log(bool p0, bool p1, bool p2, address p3) internal pure {
    6304
            bytes32 m0;
    6305
            bytes32 m1;
    6306
            bytes32 m2;
    6307
            bytes32 m3;
    6308
            bytes32 m4;
    6309
            /// @solidity memory-safe-assembly
    6310
            assembly {
    6311
                m0 := mload(0x00)
    6312
                m1 := mload(0x20)
    6313
                m2 := mload(0x40)
    6314
                m3 := mload(0x60)
    6315
                m4 := mload(0x80)
    6316
                // Selector of `log(bool,bool,bool,address)`.
    6317
                mstore(0x00, 0x8c329b1a)
    6318
                mstore(0x20, p0)
    6319
                mstore(0x40, p1)
    6320
                mstore(0x60, p2)
    6321
                mstore(0x80, p3)
    6322
            }
    6323
            _sendLogPayload(0x1c, 0x84);
    6324
            /// @solidity memory-safe-assembly
    6325
            assembly {
    6326
                mstore(0x00, m0)
    6327
                mstore(0x20, m1)
    6328
                mstore(0x40, m2)
    6329
                mstore(0x60, m3)
    6330
                mstore(0x80, m4)
    6331
            }
    6332
        }
    6333
    6334
        function log(bool p0, bool p1, bool p2, bool p3) internal pure {
    6335
            bytes32 m0;
    6336
            bytes32 m1;
    6337
            bytes32 m2;
    6338
            bytes32 m3;
    6339
            bytes32 m4;
    6340
            /// @solidity memory-safe-assembly
    6341
            assembly {
    6342
                m0 := mload(0x00)
    6343
                m1 := mload(0x20)
    6344
                m2 := mload(0x40)
    6345
                m3 := mload(0x60)
    6346
                m4 := mload(0x80)
    6347
                // Selector of `log(bool,bool,bool,bool)`.
    6348
                mstore(0x00, 0x3b2a5ce0)
    6349
                mstore(0x20, p0)
    6350
                mstore(0x40, p1)
    6351
                mstore(0x60, p2)
    6352
                mstore(0x80, p3)
    6353
            }
    6354
            _sendLogPayload(0x1c, 0x84);
    6355
            /// @solidity memory-safe-assembly
    6356
            assembly {
    6357
                mstore(0x00, m0)
    6358
                mstore(0x20, m1)
    6359
                mstore(0x40, m2)
    6360
                mstore(0x60, m3)
    6361
                mstore(0x80, m4)
    6362
            }
    6363
        }
    6364
    6365
        function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
    6366
            bytes32 m0;
    6367
            bytes32 m1;
    6368
            bytes32 m2;
    6369
            bytes32 m3;
    6370
            bytes32 m4;
    6371
            /// @solidity memory-safe-assembly
    6372
            assembly {
    6373
                m0 := mload(0x00)
    6374
                m1 := mload(0x20)
    6375
                m2 := mload(0x40)
    6376
                m3 := mload(0x60)
    6377
                m4 := mload(0x80)
    6378
                // Selector of `log(bool,bool,bool,uint256)`.
    6379
                mstore(0x00, 0x6d7045c1)
    6380
                mstore(0x20, p0)
    6381
                mstore(0x40, p1)
    6382
                mstore(0x60, p2)
    6383
                mstore(0x80, p3)
    6384
            }
    6385
            _sendLogPayload(0x1c, 0x84);
    6386
            /// @solidity memory-safe-assembly
    6387
            assembly {
    6388
                mstore(0x00, m0)
    6389
                mstore(0x20, m1)
    6390
                mstore(0x40, m2)
    6391
                mstore(0x60, m3)
    6392
                mstore(0x80, m4)
    6393
            }
    6394
        }
    6395
    6396
        function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {
    6397
            bytes32 m0;
    6398
            bytes32 m1;
    6399
            bytes32 m2;
    6400
            bytes32 m3;
    6401
            bytes32 m4;
    6402
            bytes32 m5;
    6403
            bytes32 m6;
    6404
            /// @solidity memory-safe-assembly
    6405
            assembly {
    6406
                function writeString(pos, w) {
    6407
                    let length := 0
    6408
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6409
                    mstore(pos, length)
    6410
                    let shift := sub(256, shl(3, length))
    6411
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6412
                }
    6413
                m0 := mload(0x00)
    6414
                m1 := mload(0x20)
    6415
                m2 := mload(0x40)
    6416
                m3 := mload(0x60)
    6417
                m4 := mload(0x80)
    6418
                m5 := mload(0xa0)
    6419
                m6 := mload(0xc0)
    6420
                // Selector of `log(bool,bool,bool,string)`.
    6421
                mstore(0x00, 0x2ae408d4)
    6422
                mstore(0x20, p0)
    6423
                mstore(0x40, p1)
    6424
                mstore(0x60, p2)
    6425
                mstore(0x80, 0x80)
    6426
                writeString(0xa0, p3)
    6427
            }
    6428
            _sendLogPayload(0x1c, 0xc4);
    6429
            /// @solidity memory-safe-assembly
    6430
            assembly {
    6431
                mstore(0x00, m0)
    6432
                mstore(0x20, m1)
    6433
                mstore(0x40, m2)
    6434
                mstore(0x60, m3)
    6435
                mstore(0x80, m4)
    6436
                mstore(0xa0, m5)
    6437
                mstore(0xc0, m6)
    6438
            }
    6439
        }
    6440
    6441
        function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
    6442
            bytes32 m0;
    6443
            bytes32 m1;
    6444
            bytes32 m2;
    6445
            bytes32 m3;
    6446
            bytes32 m4;
    6447
            /// @solidity memory-safe-assembly
    6448
            assembly {
    6449
                m0 := mload(0x00)
    6450
                m1 := mload(0x20)
    6451
                m2 := mload(0x40)
    6452
                m3 := mload(0x60)
    6453
                m4 := mload(0x80)
    6454
                // Selector of `log(bool,bool,uint256,address)`.
    6455
                mstore(0x00, 0x54a7a9a0)
    6456
                mstore(0x20, p0)
    6457
                mstore(0x40, p1)
    6458
                mstore(0x60, p2)
    6459
                mstore(0x80, p3)
    6460
            }
    6461
            _sendLogPayload(0x1c, 0x84);
    6462
            /// @solidity memory-safe-assembly
    6463
            assembly {
    6464
                mstore(0x00, m0)
    6465
                mstore(0x20, m1)
    6466
                mstore(0x40, m2)
    6467
                mstore(0x60, m3)
    6468
                mstore(0x80, m4)
    6469
            }
    6470
        }
    6471
    6472
        function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
    6473
            bytes32 m0;
    6474
            bytes32 m1;
    6475
            bytes32 m2;
    6476
            bytes32 m3;
    6477
            bytes32 m4;
    6478
            /// @solidity memory-safe-assembly
    6479
            assembly {
    6480
                m0 := mload(0x00)
    6481
                m1 := mload(0x20)
    6482
                m2 := mload(0x40)
    6483
                m3 := mload(0x60)
    6484
                m4 := mload(0x80)
    6485
                // Selector of `log(bool,bool,uint256,bool)`.
    6486
                mstore(0x00, 0x619e4d0e)
    6487
                mstore(0x20, p0)
    6488
                mstore(0x40, p1)
    6489
                mstore(0x60, p2)
    6490
                mstore(0x80, p3)
    6491
            }
    6492
            _sendLogPayload(0x1c, 0x84);
    6493
            /// @solidity memory-safe-assembly
    6494
            assembly {
    6495
                mstore(0x00, m0)
    6496
                mstore(0x20, m1)
    6497
                mstore(0x40, m2)
    6498
                mstore(0x60, m3)
    6499
                mstore(0x80, m4)
    6500
            }
    6501
        }
    6502
    6503
        function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
    6504
            bytes32 m0;
    6505
            bytes32 m1;
    6506
            bytes32 m2;
    6507
            bytes32 m3;
    6508
            bytes32 m4;
    6509
            /// @solidity memory-safe-assembly
    6510
            assembly {
    6511
                m0 := mload(0x00)
    6512
                m1 := mload(0x20)
    6513
                m2 := mload(0x40)
    6514
                m3 := mload(0x60)
    6515
                m4 := mload(0x80)
    6516
                // Selector of `log(bool,bool,uint256,uint256)`.
    6517
                mstore(0x00, 0x0bb00eab)
    6518
                mstore(0x20, p0)
    6519
                mstore(0x40, p1)
    6520
                mstore(0x60, p2)
    6521
                mstore(0x80, p3)
    6522
            }
    6523
            _sendLogPayload(0x1c, 0x84);
    6524
            /// @solidity memory-safe-assembly
    6525
            assembly {
    6526
                mstore(0x00, m0)
    6527
                mstore(0x20, m1)
    6528
                mstore(0x40, m2)
    6529
                mstore(0x60, m3)
    6530
                mstore(0x80, m4)
    6531
            }
    6532
        }
    6533
    6534
        function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    6535
            bytes32 m0;
    6536
            bytes32 m1;
    6537
            bytes32 m2;
    6538
            bytes32 m3;
    6539
            bytes32 m4;
    6540
            bytes32 m5;
    6541
            bytes32 m6;
    6542
            /// @solidity memory-safe-assembly
    6543
            assembly {
    6544
                function writeString(pos, w) {
    6545
                    let length := 0
    6546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6547
                    mstore(pos, length)
    6548
                    let shift := sub(256, shl(3, length))
    6549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6550
                }
    6551
                m0 := mload(0x00)
    6552
                m1 := mload(0x20)
    6553
                m2 := mload(0x40)
    6554
                m3 := mload(0x60)
    6555
                m4 := mload(0x80)
    6556
                m5 := mload(0xa0)
    6557
                m6 := mload(0xc0)
    6558
                // Selector of `log(bool,bool,uint256,string)`.
    6559
                mstore(0x00, 0x7dd4d0e0)
    6560
                mstore(0x20, p0)
    6561
                mstore(0x40, p1)
    6562
                mstore(0x60, p2)
    6563
                mstore(0x80, 0x80)
    6564
                writeString(0xa0, p3)
    6565
            }
    6566
            _sendLogPayload(0x1c, 0xc4);
    6567
            /// @solidity memory-safe-assembly
    6568
            assembly {
    6569
                mstore(0x00, m0)
    6570
                mstore(0x20, m1)
    6571
                mstore(0x40, m2)
    6572
                mstore(0x60, m3)
    6573
                mstore(0x80, m4)
    6574
                mstore(0xa0, m5)
    6575
                mstore(0xc0, m6)
    6576
            }
    6577
        }
    6578
    6579
        function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {
    6580
            bytes32 m0;
    6581
            bytes32 m1;
    6582
            bytes32 m2;
    6583
            bytes32 m3;
    6584
            bytes32 m4;
    6585
            bytes32 m5;
    6586
            bytes32 m6;
    6587
            /// @solidity memory-safe-assembly
    6588
            assembly {
    6589
                function writeString(pos, w) {
    6590
                    let length := 0
    6591
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6592
                    mstore(pos, length)
    6593
                    let shift := sub(256, shl(3, length))
    6594
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6595
                }
    6596
                m0 := mload(0x00)
    6597
                m1 := mload(0x20)
    6598
                m2 := mload(0x40)
    6599
                m3 := mload(0x60)
    6600
                m4 := mload(0x80)
    6601
                m5 := mload(0xa0)
    6602
                m6 := mload(0xc0)
    6603
                // Selector of `log(bool,bool,string,address)`.
    6604
                mstore(0x00, 0xf9ad2b89)
    6605
                mstore(0x20, p0)
    6606
                mstore(0x40, p1)
    6607
                mstore(0x60, 0x80)
    6608
                mstore(0x80, p3)
    6609
                writeString(0xa0, p2)
    6610
            }
    6611
            _sendLogPayload(0x1c, 0xc4);
    6612
            /// @solidity memory-safe-assembly
    6613
            assembly {
    6614
                mstore(0x00, m0)
    6615
                mstore(0x20, m1)
    6616
                mstore(0x40, m2)
    6617
                mstore(0x60, m3)
    6618
                mstore(0x80, m4)
    6619
                mstore(0xa0, m5)
    6620
                mstore(0xc0, m6)
    6621
            }
    6622
        }
    6623
    6624
        function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {
    6625
            bytes32 m0;
    6626
            bytes32 m1;
    6627
            bytes32 m2;
    6628
            bytes32 m3;
    6629
            bytes32 m4;
    6630
            bytes32 m5;
    6631
            bytes32 m6;
    6632
            /// @solidity memory-safe-assembly
    6633
            assembly {
    6634
                function writeString(pos, w) {
    6635
                    let length := 0
    6636
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6637
                    mstore(pos, length)
    6638
                    let shift := sub(256, shl(3, length))
    6639
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6640
                }
    6641
                m0 := mload(0x00)
    6642
                m1 := mload(0x20)
    6643
                m2 := mload(0x40)
    6644
                m3 := mload(0x60)
    6645
                m4 := mload(0x80)
    6646
                m5 := mload(0xa0)
    6647
                m6 := mload(0xc0)
    6648
                // Selector of `log(bool,bool,string,bool)`.
    6649
                mstore(0x00, 0xb857163a)
    6650
                mstore(0x20, p0)
    6651
                mstore(0x40, p1)
    6652
                mstore(0x60, 0x80)
    6653
                mstore(0x80, p3)
    6654
                writeString(0xa0, p2)
    6655
            }
    6656
            _sendLogPayload(0x1c, 0xc4);
    6657
            /// @solidity memory-safe-assembly
    6658
            assembly {
    6659
                mstore(0x00, m0)
    6660
                mstore(0x20, m1)
    6661
                mstore(0x40, m2)
    6662
                mstore(0x60, m3)
    6663
                mstore(0x80, m4)
    6664
                mstore(0xa0, m5)
    6665
                mstore(0xc0, m6)
    6666
            }
    6667
        }
    6668
    6669
        function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    6670
            bytes32 m0;
    6671
            bytes32 m1;
    6672
            bytes32 m2;
    6673
            bytes32 m3;
    6674
            bytes32 m4;
    6675
            bytes32 m5;
    6676
            bytes32 m6;
    6677
            /// @solidity memory-safe-assembly
    6678
            assembly {
    6679
                function writeString(pos, w) {
    6680
                    let length := 0
    6681
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6682
                    mstore(pos, length)
    6683
                    let shift := sub(256, shl(3, length))
    6684
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6685
                }
    6686
                m0 := mload(0x00)
    6687
                m1 := mload(0x20)
    6688
                m2 := mload(0x40)
    6689
                m3 := mload(0x60)
    6690
                m4 := mload(0x80)
    6691
                m5 := mload(0xa0)
    6692
                m6 := mload(0xc0)
    6693
                // Selector of `log(bool,bool,string,uint256)`.
    6694
                mstore(0x00, 0xe3a9ca2f)
    6695
                mstore(0x20, p0)
    6696
                mstore(0x40, p1)
    6697
                mstore(0x60, 0x80)
    6698
                mstore(0x80, p3)
    6699
                writeString(0xa0, p2)
    6700
            }
    6701
            _sendLogPayload(0x1c, 0xc4);
    6702
            /// @solidity memory-safe-assembly
    6703
            assembly {
    6704
                mstore(0x00, m0)
    6705
                mstore(0x20, m1)
    6706
                mstore(0x40, m2)
    6707
                mstore(0x60, m3)
    6708
                mstore(0x80, m4)
    6709
                mstore(0xa0, m5)
    6710
                mstore(0xc0, m6)
    6711
            }
    6712
        }
    6713
    6714
        function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    6715
            bytes32 m0;
    6716
            bytes32 m1;
    6717
            bytes32 m2;
    6718
            bytes32 m3;
    6719
            bytes32 m4;
    6720
            bytes32 m5;
    6721
            bytes32 m6;
    6722
            bytes32 m7;
    6723
            bytes32 m8;
    6724
            /// @solidity memory-safe-assembly
    6725
            assembly {
    6726
                function writeString(pos, w) {
    6727
                    let length := 0
    6728
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6729
                    mstore(pos, length)
    6730
                    let shift := sub(256, shl(3, length))
    6731
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6732
                }
    6733
                m0 := mload(0x00)
    6734
                m1 := mload(0x20)
    6735
                m2 := mload(0x40)
    6736
                m3 := mload(0x60)
    6737
                m4 := mload(0x80)
    6738
                m5 := mload(0xa0)
    6739
                m6 := mload(0xc0)
    6740
                m7 := mload(0xe0)
    6741
                m8 := mload(0x100)
    6742
                // Selector of `log(bool,bool,string,string)`.
    6743
                mstore(0x00, 0x6d1e8751)
    6744
                mstore(0x20, p0)
    6745
                mstore(0x40, p1)
    6746
                mstore(0x60, 0x80)
    6747
                mstore(0x80, 0xc0)
    6748
                writeString(0xa0, p2)
    6749
                writeString(0xe0, p3)
    6750
            }
    6751
            _sendLogPayload(0x1c, 0x104);
    6752
            /// @solidity memory-safe-assembly
    6753
            assembly {
    6754
                mstore(0x00, m0)
    6755
                mstore(0x20, m1)
    6756
                mstore(0x40, m2)
    6757
                mstore(0x60, m3)
    6758
                mstore(0x80, m4)
    6759
                mstore(0xa0, m5)
    6760
                mstore(0xc0, m6)
    6761
                mstore(0xe0, m7)
    6762
                mstore(0x100, m8)
    6763
            }
    6764
        }
    6765
    6766
        function log(bool p0, uint256 p1, address p2, address p3) internal pure {
    6767
            bytes32 m0;
    6768
            bytes32 m1;
    6769
            bytes32 m2;
    6770
            bytes32 m3;
    6771
            bytes32 m4;
    6772
            /// @solidity memory-safe-assembly
    6773
            assembly {
    6774
                m0 := mload(0x00)
    6775
                m1 := mload(0x20)
    6776
                m2 := mload(0x40)
    6777
                m3 := mload(0x60)
    6778
                m4 := mload(0x80)
    6779
                // Selector of `log(bool,uint256,address,address)`.
    6780
                mstore(0x00, 0x26f560a8)
    6781
                mstore(0x20, p0)
    6782
                mstore(0x40, p1)
    6783
                mstore(0x60, p2)
    6784
                mstore(0x80, p3)
    6785
            }
    6786
            _sendLogPayload(0x1c, 0x84);
    6787
            /// @solidity memory-safe-assembly
    6788
            assembly {
    6789
                mstore(0x00, m0)
    6790
                mstore(0x20, m1)
    6791
                mstore(0x40, m2)
    6792
                mstore(0x60, m3)
    6793
                mstore(0x80, m4)
    6794
            }
    6795
        }
    6796
    6797
        function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
    6798
            bytes32 m0;
    6799
            bytes32 m1;
    6800
            bytes32 m2;
    6801
            bytes32 m3;
    6802
            bytes32 m4;
    6803
            /// @solidity memory-safe-assembly
    6804
            assembly {
    6805
                m0 := mload(0x00)
    6806
                m1 := mload(0x20)
    6807
                m2 := mload(0x40)
    6808
                m3 := mload(0x60)
    6809
                m4 := mload(0x80)
    6810
                // Selector of `log(bool,uint256,address,bool)`.
    6811
                mstore(0x00, 0xb4c314ff)
    6812
                mstore(0x20, p0)
    6813
                mstore(0x40, p1)
    6814
                mstore(0x60, p2)
    6815
                mstore(0x80, p3)
    6816
            }
    6817
            _sendLogPayload(0x1c, 0x84);
    6818
            /// @solidity memory-safe-assembly
    6819
            assembly {
    6820
                mstore(0x00, m0)
    6821
                mstore(0x20, m1)
    6822
                mstore(0x40, m2)
    6823
                mstore(0x60, m3)
    6824
                mstore(0x80, m4)
    6825
            }
    6826
        }
    6827
    6828
        function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
    6829
            bytes32 m0;
    6830
            bytes32 m1;
    6831
            bytes32 m2;
    6832
            bytes32 m3;
    6833
            bytes32 m4;
    6834
            /// @solidity memory-safe-assembly
    6835
            assembly {
    6836
                m0 := mload(0x00)
    6837
                m1 := mload(0x20)
    6838
                m2 := mload(0x40)
    6839
                m3 := mload(0x60)
    6840
                m4 := mload(0x80)
    6841
                // Selector of `log(bool,uint256,address,uint256)`.
    6842
                mstore(0x00, 0x1537dc87)
    6843
                mstore(0x20, p0)
    6844
                mstore(0x40, p1)
    6845
                mstore(0x60, p2)
    6846
                mstore(0x80, p3)
    6847
            }
    6848
            _sendLogPayload(0x1c, 0x84);
    6849
            /// @solidity memory-safe-assembly
    6850
            assembly {
    6851
                mstore(0x00, m0)
    6852
                mstore(0x20, m1)
    6853
                mstore(0x40, m2)
    6854
                mstore(0x60, m3)
    6855
                mstore(0x80, m4)
    6856
            }
    6857
        }
    6858
    6859
        function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {
    6860
            bytes32 m0;
    6861
            bytes32 m1;
    6862
            bytes32 m2;
    6863
            bytes32 m3;
    6864
            bytes32 m4;
    6865
            bytes32 m5;
    6866
            bytes32 m6;
    6867
            /// @solidity memory-safe-assembly
    6868
            assembly {
    6869
                function writeString(pos, w) {
    6870
                    let length := 0
    6871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    6872
                    mstore(pos, length)
    6873
                    let shift := sub(256, shl(3, length))
    6874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    6875
                }
    6876
                m0 := mload(0x00)
    6877
                m1 := mload(0x20)
    6878
                m2 := mload(0x40)
    6879
                m3 := mload(0x60)
    6880
                m4 := mload(0x80)
    6881
                m5 := mload(0xa0)
    6882
                m6 := mload(0xc0)
    6883
                // Selector of `log(bool,uint256,address,string)`.
    6884
                mstore(0x00, 0x1bb3b09a)
    6885
                mstore(0x20, p0)
    6886
                mstore(0x40, p1)
    6887
                mstore(0x60, p2)
    6888
                mstore(0x80, 0x80)
    6889
                writeString(0xa0, p3)
    6890
            }
    6891
            _sendLogPayload(0x1c, 0xc4);
    6892
            /// @solidity memory-safe-assembly
    6893
            assembly {
    6894
                mstore(0x00, m0)
    6895
                mstore(0x20, m1)
    6896
                mstore(0x40, m2)
    6897
                mstore(0x60, m3)
    6898
                mstore(0x80, m4)
    6899
                mstore(0xa0, m5)
    6900
                mstore(0xc0, m6)
    6901
            }
    6902
        }
    6903
    6904
        function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
    6905
            bytes32 m0;
    6906
            bytes32 m1;
    6907
            bytes32 m2;
    6908
            bytes32 m3;
    6909
            bytes32 m4;
    6910
            /// @solidity memory-safe-assembly
    6911
            assembly {
    6912
                m0 := mload(0x00)
    6913
                m1 := mload(0x20)
    6914
                m2 := mload(0x40)
    6915
                m3 := mload(0x60)
    6916
                m4 := mload(0x80)
    6917
                // Selector of `log(bool,uint256,bool,address)`.
    6918
                mstore(0x00, 0x9acd3616)
    6919
                mstore(0x20, p0)
    6920
                mstore(0x40, p1)
    6921
                mstore(0x60, p2)
    6922
                mstore(0x80, p3)
    6923
            }
    6924
            _sendLogPayload(0x1c, 0x84);
    6925
            /// @solidity memory-safe-assembly
    6926
            assembly {
    6927
                mstore(0x00, m0)
    6928
                mstore(0x20, m1)
    6929
                mstore(0x40, m2)
    6930
                mstore(0x60, m3)
    6931
                mstore(0x80, m4)
    6932
            }
    6933
        }
    6934
    6935
        function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
    6936
            bytes32 m0;
    6937
            bytes32 m1;
    6938
            bytes32 m2;
    6939
            bytes32 m3;
    6940
            bytes32 m4;
    6941
            /// @solidity memory-safe-assembly
    6942
            assembly {
    6943
                m0 := mload(0x00)
    6944
                m1 := mload(0x20)
    6945
                m2 := mload(0x40)
    6946
                m3 := mload(0x60)
    6947
                m4 := mload(0x80)
    6948
                // Selector of `log(bool,uint256,bool,bool)`.
    6949
                mstore(0x00, 0xceb5f4d7)
    6950
                mstore(0x20, p0)
    6951
                mstore(0x40, p1)
    6952
                mstore(0x60, p2)
    6953
                mstore(0x80, p3)
    6954
            }
    6955
            _sendLogPayload(0x1c, 0x84);
    6956
            /// @solidity memory-safe-assembly
    6957
            assembly {
    6958
                mstore(0x00, m0)
    6959
                mstore(0x20, m1)
    6960
                mstore(0x40, m2)
    6961
                mstore(0x60, m3)
    6962
                mstore(0x80, m4)
    6963
            }
    6964
        }
    6965
    6966
        function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
    6967
            bytes32 m0;
    6968
            bytes32 m1;
    6969
            bytes32 m2;
    6970
            bytes32 m3;
    6971
            bytes32 m4;
    6972
            /// @solidity memory-safe-assembly
    6973
            assembly {
    6974
                m0 := mload(0x00)
    6975
                m1 := mload(0x20)
    6976
                m2 := mload(0x40)
    6977
                m3 := mload(0x60)
    6978
                m4 := mload(0x80)
    6979
                // Selector of `log(bool,uint256,bool,uint256)`.
    6980
                mstore(0x00, 0x7f9bbca2)
    6981
                mstore(0x20, p0)
    6982
                mstore(0x40, p1)
    6983
                mstore(0x60, p2)
    6984
                mstore(0x80, p3)
    6985
            }
    6986
            _sendLogPayload(0x1c, 0x84);
    6987
            /// @solidity memory-safe-assembly
    6988
            assembly {
    6989
                mstore(0x00, m0)
    6990
                mstore(0x20, m1)
    6991
                mstore(0x40, m2)
    6992
                mstore(0x60, m3)
    6993
                mstore(0x80, m4)
    6994
            }
    6995
        }
    6996
    6997
        function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    6998
            bytes32 m0;
    6999
            bytes32 m1;
    7000
            bytes32 m2;
    7001
            bytes32 m3;
    7002
            bytes32 m4;
    7003
            bytes32 m5;
    7004
            bytes32 m6;
    7005
            /// @solidity memory-safe-assembly
    7006
            assembly {
    7007
                function writeString(pos, w) {
    7008
                    let length := 0
    7009
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7010
                    mstore(pos, length)
    7011
                    let shift := sub(256, shl(3, length))
    7012
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7013
                }
    7014
                m0 := mload(0x00)
    7015
                m1 := mload(0x20)
    7016
                m2 := mload(0x40)
    7017
                m3 := mload(0x60)
    7018
                m4 := mload(0x80)
    7019
                m5 := mload(0xa0)
    7020
                m6 := mload(0xc0)
    7021
                // Selector of `log(bool,uint256,bool,string)`.
    7022
                mstore(0x00, 0x9143dbb1)
    7023
                mstore(0x20, p0)
    7024
                mstore(0x40, p1)
    7025
                mstore(0x60, p2)
    7026
                mstore(0x80, 0x80)
    7027
                writeString(0xa0, p3)
    7028
            }
    7029
            _sendLogPayload(0x1c, 0xc4);
    7030
            /// @solidity memory-safe-assembly
    7031
            assembly {
    7032
                mstore(0x00, m0)
    7033
                mstore(0x20, m1)
    7034
                mstore(0x40, m2)
    7035
                mstore(0x60, m3)
    7036
                mstore(0x80, m4)
    7037
                mstore(0xa0, m5)
    7038
                mstore(0xc0, m6)
    7039
            }
    7040
        }
    7041
    7042
        function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
    7043
            bytes32 m0;
    7044
            bytes32 m1;
    7045
            bytes32 m2;
    7046
            bytes32 m3;
    7047
            bytes32 m4;
    7048
            /// @solidity memory-safe-assembly
    7049
            assembly {
    7050
                m0 := mload(0x00)
    7051
                m1 := mload(0x20)
    7052
                m2 := mload(0x40)
    7053
                m3 := mload(0x60)
    7054
                m4 := mload(0x80)
    7055
                // Selector of `log(bool,uint256,uint256,address)`.
    7056
                mstore(0x00, 0x00dd87b9)
    7057
                mstore(0x20, p0)
    7058
                mstore(0x40, p1)
    7059
                mstore(0x60, p2)
    7060
                mstore(0x80, p3)
    7061
            }
    7062
            _sendLogPayload(0x1c, 0x84);
    7063
            /// @solidity memory-safe-assembly
    7064
            assembly {
    7065
                mstore(0x00, m0)
    7066
                mstore(0x20, m1)
    7067
                mstore(0x40, m2)
    7068
                mstore(0x60, m3)
    7069
                mstore(0x80, m4)
    7070
            }
    7071
        }
    7072
    7073
        function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
    7074
            bytes32 m0;
    7075
            bytes32 m1;
    7076
            bytes32 m2;
    7077
            bytes32 m3;
    7078
            bytes32 m4;
    7079
            /// @solidity memory-safe-assembly
    7080
            assembly {
    7081
                m0 := mload(0x00)
    7082
                m1 := mload(0x20)
    7083
                m2 := mload(0x40)
    7084
                m3 := mload(0x60)
    7085
                m4 := mload(0x80)
    7086
                // Selector of `log(bool,uint256,uint256,bool)`.
    7087
                mstore(0x00, 0xbe984353)
    7088
                mstore(0x20, p0)
    7089
                mstore(0x40, p1)
    7090
                mstore(0x60, p2)
    7091
                mstore(0x80, p3)
    7092
            }
    7093
            _sendLogPayload(0x1c, 0x84);
    7094
            /// @solidity memory-safe-assembly
    7095
            assembly {
    7096
                mstore(0x00, m0)
    7097
                mstore(0x20, m1)
    7098
                mstore(0x40, m2)
    7099
                mstore(0x60, m3)
    7100
                mstore(0x80, m4)
    7101
            }
    7102
        }
    7103
    7104
        function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    7105
            bytes32 m0;
    7106
            bytes32 m1;
    7107
            bytes32 m2;
    7108
            bytes32 m3;
    7109
            bytes32 m4;
    7110
            /// @solidity memory-safe-assembly
    7111
            assembly {
    7112
                m0 := mload(0x00)
    7113
                m1 := mload(0x20)
    7114
                m2 := mload(0x40)
    7115
                m3 := mload(0x60)
    7116
                m4 := mload(0x80)
    7117
                // Selector of `log(bool,uint256,uint256,uint256)`.
    7118
                mstore(0x00, 0x374bb4b2)
    7119
                mstore(0x20, p0)
    7120
                mstore(0x40, p1)
    7121
                mstore(0x60, p2)
    7122
                mstore(0x80, p3)
    7123
            }
    7124
            _sendLogPayload(0x1c, 0x84);
    7125
            /// @solidity memory-safe-assembly
    7126
            assembly {
    7127
                mstore(0x00, m0)
    7128
                mstore(0x20, m1)
    7129
                mstore(0x40, m2)
    7130
                mstore(0x60, m3)
    7131
                mstore(0x80, m4)
    7132
            }
    7133
        }
    7134
    7135
        function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    7136
            bytes32 m0;
    7137
            bytes32 m1;
    7138
            bytes32 m2;
    7139
            bytes32 m3;
    7140
            bytes32 m4;
    7141
            bytes32 m5;
    7142
            bytes32 m6;
    7143
            /// @solidity memory-safe-assembly
    7144
            assembly {
    7145
                function writeString(pos, w) {
    7146
                    let length := 0
    7147
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7148
                    mstore(pos, length)
    7149
                    let shift := sub(256, shl(3, length))
    7150
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7151
                }
    7152
                m0 := mload(0x00)
    7153
                m1 := mload(0x20)
    7154
                m2 := mload(0x40)
    7155
                m3 := mload(0x60)
    7156
                m4 := mload(0x80)
    7157
                m5 := mload(0xa0)
    7158
                m6 := mload(0xc0)
    7159
                // Selector of `log(bool,uint256,uint256,string)`.
    7160
                mstore(0x00, 0x8e69fb5d)
    7161
                mstore(0x20, p0)
    7162
                mstore(0x40, p1)
    7163
                mstore(0x60, p2)
    7164
                mstore(0x80, 0x80)
    7165
                writeString(0xa0, p3)
    7166
            }
    7167
            _sendLogPayload(0x1c, 0xc4);
    7168
            /// @solidity memory-safe-assembly
    7169
            assembly {
    7170
                mstore(0x00, m0)
    7171
                mstore(0x20, m1)
    7172
                mstore(0x40, m2)
    7173
                mstore(0x60, m3)
    7174
                mstore(0x80, m4)
    7175
                mstore(0xa0, m5)
    7176
                mstore(0xc0, m6)
    7177
            }
    7178
        }
    7179
    7180
        function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {
    7181
            bytes32 m0;
    7182
            bytes32 m1;
    7183
            bytes32 m2;
    7184
            bytes32 m3;
    7185
            bytes32 m4;
    7186
            bytes32 m5;
    7187
            bytes32 m6;
    7188
            /// @solidity memory-safe-assembly
    7189
            assembly {
    7190
                function writeString(pos, w) {
    7191
                    let length := 0
    7192
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7193
                    mstore(pos, length)
    7194
                    let shift := sub(256, shl(3, length))
    7195
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7196
                }
    7197
                m0 := mload(0x00)
    7198
                m1 := mload(0x20)
    7199
                m2 := mload(0x40)
    7200
                m3 := mload(0x60)
    7201
                m4 := mload(0x80)
    7202
                m5 := mload(0xa0)
    7203
                m6 := mload(0xc0)
    7204
                // Selector of `log(bool,uint256,string,address)`.
    7205
                mstore(0x00, 0xfedd1fff)
    7206
                mstore(0x20, p0)
    7207
                mstore(0x40, p1)
    7208
                mstore(0x60, 0x80)
    7209
                mstore(0x80, p3)
    7210
                writeString(0xa0, p2)
    7211
            }
    7212
            _sendLogPayload(0x1c, 0xc4);
    7213
            /// @solidity memory-safe-assembly
    7214
            assembly {
    7215
                mstore(0x00, m0)
    7216
                mstore(0x20, m1)
    7217
                mstore(0x40, m2)
    7218
                mstore(0x60, m3)
    7219
                mstore(0x80, m4)
    7220
                mstore(0xa0, m5)
    7221
                mstore(0xc0, m6)
    7222
            }
    7223
        }
    7224
    7225
        function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    7226
            bytes32 m0;
    7227
            bytes32 m1;
    7228
            bytes32 m2;
    7229
            bytes32 m3;
    7230
            bytes32 m4;
    7231
            bytes32 m5;
    7232
            bytes32 m6;
    7233
            /// @solidity memory-safe-assembly
    7234
            assembly {
    7235
                function writeString(pos, w) {
    7236
                    let length := 0
    7237
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7238
                    mstore(pos, length)
    7239
                    let shift := sub(256, shl(3, length))
    7240
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7241
                }
    7242
                m0 := mload(0x00)
    7243
                m1 := mload(0x20)
    7244
                m2 := mload(0x40)
    7245
                m3 := mload(0x60)
    7246
                m4 := mload(0x80)
    7247
                m5 := mload(0xa0)
    7248
                m6 := mload(0xc0)
    7249
                // Selector of `log(bool,uint256,string,bool)`.
    7250
                mstore(0x00, 0xe5e70b2b)
    7251
                mstore(0x20, p0)
    7252
                mstore(0x40, p1)
    7253
                mstore(0x60, 0x80)
    7254
                mstore(0x80, p3)
    7255
                writeString(0xa0, p2)
    7256
            }
    7257
            _sendLogPayload(0x1c, 0xc4);
    7258
            /// @solidity memory-safe-assembly
    7259
            assembly {
    7260
                mstore(0x00, m0)
    7261
                mstore(0x20, m1)
    7262
                mstore(0x40, m2)
    7263
                mstore(0x60, m3)
    7264
                mstore(0x80, m4)
    7265
                mstore(0xa0, m5)
    7266
                mstore(0xc0, m6)
    7267
            }
    7268
        }
    7269
    7270
        function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    7271
            bytes32 m0;
    7272
            bytes32 m1;
    7273
            bytes32 m2;
    7274
            bytes32 m3;
    7275
            bytes32 m4;
    7276
            bytes32 m5;
    7277
            bytes32 m6;
    7278
            /// @solidity memory-safe-assembly
    7279
            assembly {
    7280
                function writeString(pos, w) {
    7281
                    let length := 0
    7282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7283
                    mstore(pos, length)
    7284
                    let shift := sub(256, shl(3, length))
    7285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7286
                }
    7287
                m0 := mload(0x00)
    7288
                m1 := mload(0x20)
    7289
                m2 := mload(0x40)
    7290
                m3 := mload(0x60)
    7291
                m4 := mload(0x80)
    7292
                m5 := mload(0xa0)
    7293
                m6 := mload(0xc0)
    7294
                // Selector of `log(bool,uint256,string,uint256)`.
    7295
                mstore(0x00, 0x6a1199e2)
    7296
                mstore(0x20, p0)
    7297
                mstore(0x40, p1)
    7298
                mstore(0x60, 0x80)
    7299
                mstore(0x80, p3)
    7300
                writeString(0xa0, p2)
    7301
            }
    7302
            _sendLogPayload(0x1c, 0xc4);
    7303
            /// @solidity memory-safe-assembly
    7304
            assembly {
    7305
                mstore(0x00, m0)
    7306
                mstore(0x20, m1)
    7307
                mstore(0x40, m2)
    7308
                mstore(0x60, m3)
    7309
                mstore(0x80, m4)
    7310
                mstore(0xa0, m5)
    7311
                mstore(0xc0, m6)
    7312
            }
    7313
        }
    7314
    7315
        function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    7316
            bytes32 m0;
    7317
            bytes32 m1;
    7318
            bytes32 m2;
    7319
            bytes32 m3;
    7320
            bytes32 m4;
    7321
            bytes32 m5;
    7322
            bytes32 m6;
    7323
            bytes32 m7;
    7324
            bytes32 m8;
    7325
            /// @solidity memory-safe-assembly
    7326
            assembly {
    7327
                function writeString(pos, w) {
    7328
                    let length := 0
    7329
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7330
                    mstore(pos, length)
    7331
                    let shift := sub(256, shl(3, length))
    7332
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7333
                }
    7334
                m0 := mload(0x00)
    7335
                m1 := mload(0x20)
    7336
                m2 := mload(0x40)
    7337
                m3 := mload(0x60)
    7338
                m4 := mload(0x80)
    7339
                m5 := mload(0xa0)
    7340
                m6 := mload(0xc0)
    7341
                m7 := mload(0xe0)
    7342
                m8 := mload(0x100)
    7343
                // Selector of `log(bool,uint256,string,string)`.
    7344
                mstore(0x00, 0xf5bc2249)
    7345
                mstore(0x20, p0)
    7346
                mstore(0x40, p1)
    7347
                mstore(0x60, 0x80)
    7348
                mstore(0x80, 0xc0)
    7349
                writeString(0xa0, p2)
    7350
                writeString(0xe0, p3)
    7351
            }
    7352
            _sendLogPayload(0x1c, 0x104);
    7353
            /// @solidity memory-safe-assembly
    7354
            assembly {
    7355
                mstore(0x00, m0)
    7356
                mstore(0x20, m1)
    7357
                mstore(0x40, m2)
    7358
                mstore(0x60, m3)
    7359
                mstore(0x80, m4)
    7360
                mstore(0xa0, m5)
    7361
                mstore(0xc0, m6)
    7362
                mstore(0xe0, m7)
    7363
                mstore(0x100, m8)
    7364
            }
    7365
        }
    7366
    7367
        function log(bool p0, bytes32 p1, address p2, address p3) internal pure {
    7368
            bytes32 m0;
    7369
            bytes32 m1;
    7370
            bytes32 m2;
    7371
            bytes32 m3;
    7372
            bytes32 m4;
    7373
            bytes32 m5;
    7374
            bytes32 m6;
    7375
            /// @solidity memory-safe-assembly
    7376
            assembly {
    7377
                function writeString(pos, w) {
    7378
                    let length := 0
    7379
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7380
                    mstore(pos, length)
    7381
                    let shift := sub(256, shl(3, length))
    7382
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7383
                }
    7384
                m0 := mload(0x00)
    7385
                m1 := mload(0x20)
    7386
                m2 := mload(0x40)
    7387
                m3 := mload(0x60)
    7388
                m4 := mload(0x80)
    7389
                m5 := mload(0xa0)
    7390
                m6 := mload(0xc0)
    7391
                // Selector of `log(bool,string,address,address)`.
    7392
                mstore(0x00, 0x2b2b18dc)
    7393
                mstore(0x20, p0)
    7394
                mstore(0x40, 0x80)
    7395
                mstore(0x60, p2)
    7396
                mstore(0x80, p3)
    7397
                writeString(0xa0, p1)
    7398
            }
    7399
            _sendLogPayload(0x1c, 0xc4);
    7400
            /// @solidity memory-safe-assembly
    7401
            assembly {
    7402
                mstore(0x00, m0)
    7403
                mstore(0x20, m1)
    7404
                mstore(0x40, m2)
    7405
                mstore(0x60, m3)
    7406
                mstore(0x80, m4)
    7407
                mstore(0xa0, m5)
    7408
                mstore(0xc0, m6)
    7409
            }
    7410
        }
    7411
    7412
        function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {
    7413
            bytes32 m0;
    7414
            bytes32 m1;
    7415
            bytes32 m2;
    7416
            bytes32 m3;
    7417
            bytes32 m4;
    7418
            bytes32 m5;
    7419
            bytes32 m6;
    7420
            /// @solidity memory-safe-assembly
    7421
            assembly {
    7422
                function writeString(pos, w) {
    7423
                    let length := 0
    7424
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7425
                    mstore(pos, length)
    7426
                    let shift := sub(256, shl(3, length))
    7427
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7428
                }
    7429
                m0 := mload(0x00)
    7430
                m1 := mload(0x20)
    7431
                m2 := mload(0x40)
    7432
                m3 := mload(0x60)
    7433
                m4 := mload(0x80)
    7434
                m5 := mload(0xa0)
    7435
                m6 := mload(0xc0)
    7436
                // Selector of `log(bool,string,address,bool)`.
    7437
                mstore(0x00, 0x6dd434ca)
    7438
                mstore(0x20, p0)
    7439
                mstore(0x40, 0x80)
    7440
                mstore(0x60, p2)
    7441
                mstore(0x80, p3)
    7442
                writeString(0xa0, p1)
    7443
            }
    7444
            _sendLogPayload(0x1c, 0xc4);
    7445
            /// @solidity memory-safe-assembly
    7446
            assembly {
    7447
                mstore(0x00, m0)
    7448
                mstore(0x20, m1)
    7449
                mstore(0x40, m2)
    7450
                mstore(0x60, m3)
    7451
                mstore(0x80, m4)
    7452
                mstore(0xa0, m5)
    7453
                mstore(0xc0, m6)
    7454
            }
    7455
        }
    7456
    7457
        function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {
    7458
            bytes32 m0;
    7459
            bytes32 m1;
    7460
            bytes32 m2;
    7461
            bytes32 m3;
    7462
            bytes32 m4;
    7463
            bytes32 m5;
    7464
            bytes32 m6;
    7465
            /// @solidity memory-safe-assembly
    7466
            assembly {
    7467
                function writeString(pos, w) {
    7468
                    let length := 0
    7469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7470
                    mstore(pos, length)
    7471
                    let shift := sub(256, shl(3, length))
    7472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7473
                }
    7474
                m0 := mload(0x00)
    7475
                m1 := mload(0x20)
    7476
                m2 := mload(0x40)
    7477
                m3 := mload(0x60)
    7478
                m4 := mload(0x80)
    7479
                m5 := mload(0xa0)
    7480
                m6 := mload(0xc0)
    7481
                // Selector of `log(bool,string,address,uint256)`.
    7482
                mstore(0x00, 0xa5cada94)
    7483
                mstore(0x20, p0)
    7484
                mstore(0x40, 0x80)
    7485
                mstore(0x60, p2)
    7486
                mstore(0x80, p3)
    7487
                writeString(0xa0, p1)
    7488
            }
    7489
            _sendLogPayload(0x1c, 0xc4);
    7490
            /// @solidity memory-safe-assembly
    7491
            assembly {
    7492
                mstore(0x00, m0)
    7493
                mstore(0x20, m1)
    7494
                mstore(0x40, m2)
    7495
                mstore(0x60, m3)
    7496
                mstore(0x80, m4)
    7497
                mstore(0xa0, m5)
    7498
                mstore(0xc0, m6)
    7499
            }
    7500
        }
    7501
    7502
        function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    7503
            bytes32 m0;
    7504
            bytes32 m1;
    7505
            bytes32 m2;
    7506
            bytes32 m3;
    7507
            bytes32 m4;
    7508
            bytes32 m5;
    7509
            bytes32 m6;
    7510
            bytes32 m7;
    7511
            bytes32 m8;
    7512
            /// @solidity memory-safe-assembly
    7513
            assembly {
    7514
                function writeString(pos, w) {
    7515
                    let length := 0
    7516
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7517
                    mstore(pos, length)
    7518
                    let shift := sub(256, shl(3, length))
    7519
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7520
                }
    7521
                m0 := mload(0x00)
    7522
                m1 := mload(0x20)
    7523
                m2 := mload(0x40)
    7524
                m3 := mload(0x60)
    7525
                m4 := mload(0x80)
    7526
                m5 := mload(0xa0)
    7527
                m6 := mload(0xc0)
    7528
                m7 := mload(0xe0)
    7529
                m8 := mload(0x100)
    7530
                // Selector of `log(bool,string,address,string)`.
    7531
                mstore(0x00, 0x12d6c788)
    7532
                mstore(0x20, p0)
    7533
                mstore(0x40, 0x80)
    7534
                mstore(0x60, p2)
    7535
                mstore(0x80, 0xc0)
    7536
                writeString(0xa0, p1)
    7537
                writeString(0xe0, p3)
    7538
            }
    7539
            _sendLogPayload(0x1c, 0x104);
    7540
            /// @solidity memory-safe-assembly
    7541
            assembly {
    7542
                mstore(0x00, m0)
    7543
                mstore(0x20, m1)
    7544
                mstore(0x40, m2)
    7545
                mstore(0x60, m3)
    7546
                mstore(0x80, m4)
    7547
                mstore(0xa0, m5)
    7548
                mstore(0xc0, m6)
    7549
                mstore(0xe0, m7)
    7550
                mstore(0x100, m8)
    7551
            }
    7552
        }
    7553
    7554
        function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {
    7555
            bytes32 m0;
    7556
            bytes32 m1;
    7557
            bytes32 m2;
    7558
            bytes32 m3;
    7559
            bytes32 m4;
    7560
            bytes32 m5;
    7561
            bytes32 m6;
    7562
            /// @solidity memory-safe-assembly
    7563
            assembly {
    7564
                function writeString(pos, w) {
    7565
                    let length := 0
    7566
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7567
                    mstore(pos, length)
    7568
                    let shift := sub(256, shl(3, length))
    7569
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7570
                }
    7571
                m0 := mload(0x00)
    7572
                m1 := mload(0x20)
    7573
                m2 := mload(0x40)
    7574
                m3 := mload(0x60)
    7575
                m4 := mload(0x80)
    7576
                m5 := mload(0xa0)
    7577
                m6 := mload(0xc0)
    7578
                // Selector of `log(bool,string,bool,address)`.
    7579
                mstore(0x00, 0x538e06ab)
    7580
                mstore(0x20, p0)
    7581
                mstore(0x40, 0x80)
    7582
                mstore(0x60, p2)
    7583
                mstore(0x80, p3)
    7584
                writeString(0xa0, p1)
    7585
            }
    7586
            _sendLogPayload(0x1c, 0xc4);
    7587
            /// @solidity memory-safe-assembly
    7588
            assembly {
    7589
                mstore(0x00, m0)
    7590
                mstore(0x20, m1)
    7591
                mstore(0x40, m2)
    7592
                mstore(0x60, m3)
    7593
                mstore(0x80, m4)
    7594
                mstore(0xa0, m5)
    7595
                mstore(0xc0, m6)
    7596
            }
    7597
        }
    7598
    7599
        function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {
    7600
            bytes32 m0;
    7601
            bytes32 m1;
    7602
            bytes32 m2;
    7603
            bytes32 m3;
    7604
            bytes32 m4;
    7605
            bytes32 m5;
    7606
            bytes32 m6;
    7607
            /// @solidity memory-safe-assembly
    7608
            assembly {
    7609
                function writeString(pos, w) {
    7610
                    let length := 0
    7611
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7612
                    mstore(pos, length)
    7613
                    let shift := sub(256, shl(3, length))
    7614
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7615
                }
    7616
                m0 := mload(0x00)
    7617
                m1 := mload(0x20)
    7618
                m2 := mload(0x40)
    7619
                m3 := mload(0x60)
    7620
                m4 := mload(0x80)
    7621
                m5 := mload(0xa0)
    7622
                m6 := mload(0xc0)
    7623
                // Selector of `log(bool,string,bool,bool)`.
    7624
                mstore(0x00, 0xdc5e935b)
    7625
                mstore(0x20, p0)
    7626
                mstore(0x40, 0x80)
    7627
                mstore(0x60, p2)
    7628
                mstore(0x80, p3)
    7629
                writeString(0xa0, p1)
    7630
            }
    7631
            _sendLogPayload(0x1c, 0xc4);
    7632
            /// @solidity memory-safe-assembly
    7633
            assembly {
    7634
                mstore(0x00, m0)
    7635
                mstore(0x20, m1)
    7636
                mstore(0x40, m2)
    7637
                mstore(0x60, m3)
    7638
                mstore(0x80, m4)
    7639
                mstore(0xa0, m5)
    7640
                mstore(0xc0, m6)
    7641
            }
    7642
        }
    7643
    7644
        function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    7645
            bytes32 m0;
    7646
            bytes32 m1;
    7647
            bytes32 m2;
    7648
            bytes32 m3;
    7649
            bytes32 m4;
    7650
            bytes32 m5;
    7651
            bytes32 m6;
    7652
            /// @solidity memory-safe-assembly
    7653
            assembly {
    7654
                function writeString(pos, w) {
    7655
                    let length := 0
    7656
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7657
                    mstore(pos, length)
    7658
                    let shift := sub(256, shl(3, length))
    7659
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7660
                }
    7661
                m0 := mload(0x00)
    7662
                m1 := mload(0x20)
    7663
                m2 := mload(0x40)
    7664
                m3 := mload(0x60)
    7665
                m4 := mload(0x80)
    7666
                m5 := mload(0xa0)
    7667
                m6 := mload(0xc0)
    7668
                // Selector of `log(bool,string,bool,uint256)`.
    7669
                mstore(0x00, 0x1606a393)
    7670
                mstore(0x20, p0)
    7671
                mstore(0x40, 0x80)
    7672
                mstore(0x60, p2)
    7673
                mstore(0x80, p3)
    7674
                writeString(0xa0, p1)
    7675
            }
    7676
            _sendLogPayload(0x1c, 0xc4);
    7677
            /// @solidity memory-safe-assembly
    7678
            assembly {
    7679
                mstore(0x00, m0)
    7680
                mstore(0x20, m1)
    7681
                mstore(0x40, m2)
    7682
                mstore(0x60, m3)
    7683
                mstore(0x80, m4)
    7684
                mstore(0xa0, m5)
    7685
                mstore(0xc0, m6)
    7686
            }
    7687
        }
    7688
    7689
        function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    7690
            bytes32 m0;
    7691
            bytes32 m1;
    7692
            bytes32 m2;
    7693
            bytes32 m3;
    7694
            bytes32 m4;
    7695
            bytes32 m5;
    7696
            bytes32 m6;
    7697
            bytes32 m7;
    7698
            bytes32 m8;
    7699
            /// @solidity memory-safe-assembly
    7700
            assembly {
    7701
                function writeString(pos, w) {
    7702
                    let length := 0
    7703
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7704
                    mstore(pos, length)
    7705
                    let shift := sub(256, shl(3, length))
    7706
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7707
                }
    7708
                m0 := mload(0x00)
    7709
                m1 := mload(0x20)
    7710
                m2 := mload(0x40)
    7711
                m3 := mload(0x60)
    7712
                m4 := mload(0x80)
    7713
                m5 := mload(0xa0)
    7714
                m6 := mload(0xc0)
    7715
                m7 := mload(0xe0)
    7716
                m8 := mload(0x100)
    7717
                // Selector of `log(bool,string,bool,string)`.
    7718
                mstore(0x00, 0x483d0416)
    7719
                mstore(0x20, p0)
    7720
                mstore(0x40, 0x80)
    7721
                mstore(0x60, p2)
    7722
                mstore(0x80, 0xc0)
    7723
                writeString(0xa0, p1)
    7724
                writeString(0xe0, p3)
    7725
            }
    7726
            _sendLogPayload(0x1c, 0x104);
    7727
            /// @solidity memory-safe-assembly
    7728
            assembly {
    7729
                mstore(0x00, m0)
    7730
                mstore(0x20, m1)
    7731
                mstore(0x40, m2)
    7732
                mstore(0x60, m3)
    7733
                mstore(0x80, m4)
    7734
                mstore(0xa0, m5)
    7735
                mstore(0xc0, m6)
    7736
                mstore(0xe0, m7)
    7737
                mstore(0x100, m8)
    7738
            }
    7739
        }
    7740
    7741
        function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {
    7742
            bytes32 m0;
    7743
            bytes32 m1;
    7744
            bytes32 m2;
    7745
            bytes32 m3;
    7746
            bytes32 m4;
    7747
            bytes32 m5;
    7748
            bytes32 m6;
    7749
            /// @solidity memory-safe-assembly
    7750
            assembly {
    7751
                function writeString(pos, w) {
    7752
                    let length := 0
    7753
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7754
                    mstore(pos, length)
    7755
                    let shift := sub(256, shl(3, length))
    7756
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7757
                }
    7758
                m0 := mload(0x00)
    7759
                m1 := mload(0x20)
    7760
                m2 := mload(0x40)
    7761
                m3 := mload(0x60)
    7762
                m4 := mload(0x80)
    7763
                m5 := mload(0xa0)
    7764
                m6 := mload(0xc0)
    7765
                // Selector of `log(bool,string,uint256,address)`.
    7766
                mstore(0x00, 0x1596a1ce)
    7767
                mstore(0x20, p0)
    7768
                mstore(0x40, 0x80)
    7769
                mstore(0x60, p2)
    7770
                mstore(0x80, p3)
    7771
                writeString(0xa0, p1)
    7772
            }
    7773
            _sendLogPayload(0x1c, 0xc4);
    7774
            /// @solidity memory-safe-assembly
    7775
            assembly {
    7776
                mstore(0x00, m0)
    7777
                mstore(0x20, m1)
    7778
                mstore(0x40, m2)
    7779
                mstore(0x60, m3)
    7780
                mstore(0x80, m4)
    7781
                mstore(0xa0, m5)
    7782
                mstore(0xc0, m6)
    7783
            }
    7784
        }
    7785
    7786
        function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    7787
            bytes32 m0;
    7788
            bytes32 m1;
    7789
            bytes32 m2;
    7790
            bytes32 m3;
    7791
            bytes32 m4;
    7792
            bytes32 m5;
    7793
            bytes32 m6;
    7794
            /// @solidity memory-safe-assembly
    7795
            assembly {
    7796
                function writeString(pos, w) {
    7797
                    let length := 0
    7798
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7799
                    mstore(pos, length)
    7800
                    let shift := sub(256, shl(3, length))
    7801
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7802
                }
    7803
                m0 := mload(0x00)
    7804
                m1 := mload(0x20)
    7805
                m2 := mload(0x40)
    7806
                m3 := mload(0x60)
    7807
                m4 := mload(0x80)
    7808
                m5 := mload(0xa0)
    7809
                m6 := mload(0xc0)
    7810
                // Selector of `log(bool,string,uint256,bool)`.
    7811
                mstore(0x00, 0x6b0e5d53)
    7812
                mstore(0x20, p0)
    7813
                mstore(0x40, 0x80)
    7814
                mstore(0x60, p2)
    7815
                mstore(0x80, p3)
    7816
                writeString(0xa0, p1)
    7817
            }
    7818
            _sendLogPayload(0x1c, 0xc4);
    7819
            /// @solidity memory-safe-assembly
    7820
            assembly {
    7821
                mstore(0x00, m0)
    7822
                mstore(0x20, m1)
    7823
                mstore(0x40, m2)
    7824
                mstore(0x60, m3)
    7825
                mstore(0x80, m4)
    7826
                mstore(0xa0, m5)
    7827
                mstore(0xc0, m6)
    7828
            }
    7829
        }
    7830
    7831
        function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    7832
            bytes32 m0;
    7833
            bytes32 m1;
    7834
            bytes32 m2;
    7835
            bytes32 m3;
    7836
            bytes32 m4;
    7837
            bytes32 m5;
    7838
            bytes32 m6;
    7839
            /// @solidity memory-safe-assembly
    7840
            assembly {
    7841
                function writeString(pos, w) {
    7842
                    let length := 0
    7843
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7844
                    mstore(pos, length)
    7845
                    let shift := sub(256, shl(3, length))
    7846
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7847
                }
    7848
                m0 := mload(0x00)
    7849
                m1 := mload(0x20)
    7850
                m2 := mload(0x40)
    7851
                m3 := mload(0x60)
    7852
                m4 := mload(0x80)
    7853
                m5 := mload(0xa0)
    7854
                m6 := mload(0xc0)
    7855
                // Selector of `log(bool,string,uint256,uint256)`.
    7856
                mstore(0x00, 0x28863fcb)
    7857
                mstore(0x20, p0)
    7858
                mstore(0x40, 0x80)
    7859
                mstore(0x60, p2)
    7860
                mstore(0x80, p3)
    7861
                writeString(0xa0, p1)
    7862
            }
    7863
            _sendLogPayload(0x1c, 0xc4);
    7864
            /// @solidity memory-safe-assembly
    7865
            assembly {
    7866
                mstore(0x00, m0)
    7867
                mstore(0x20, m1)
    7868
                mstore(0x40, m2)
    7869
                mstore(0x60, m3)
    7870
                mstore(0x80, m4)
    7871
                mstore(0xa0, m5)
    7872
                mstore(0xc0, m6)
    7873
            }
    7874
        }
    7875
    7876
        function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    7877
            bytes32 m0;
    7878
            bytes32 m1;
    7879
            bytes32 m2;
    7880
            bytes32 m3;
    7881
            bytes32 m4;
    7882
            bytes32 m5;
    7883
            bytes32 m6;
    7884
            bytes32 m7;
    7885
            bytes32 m8;
    7886
            /// @solidity memory-safe-assembly
    7887
            assembly {
    7888
                function writeString(pos, w) {
    7889
                    let length := 0
    7890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7891
                    mstore(pos, length)
    7892
                    let shift := sub(256, shl(3, length))
    7893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7894
                }
    7895
                m0 := mload(0x00)
    7896
                m1 := mload(0x20)
    7897
                m2 := mload(0x40)
    7898
                m3 := mload(0x60)
    7899
                m4 := mload(0x80)
    7900
                m5 := mload(0xa0)
    7901
                m6 := mload(0xc0)
    7902
                m7 := mload(0xe0)
    7903
                m8 := mload(0x100)
    7904
                // Selector of `log(bool,string,uint256,string)`.
    7905
                mstore(0x00, 0x1ad96de6)
    7906
                mstore(0x20, p0)
    7907
                mstore(0x40, 0x80)
    7908
                mstore(0x60, p2)
    7909
                mstore(0x80, 0xc0)
    7910
                writeString(0xa0, p1)
    7911
                writeString(0xe0, p3)
    7912
            }
    7913
            _sendLogPayload(0x1c, 0x104);
    7914
            /// @solidity memory-safe-assembly
    7915
            assembly {
    7916
                mstore(0x00, m0)
    7917
                mstore(0x20, m1)
    7918
                mstore(0x40, m2)
    7919
                mstore(0x60, m3)
    7920
                mstore(0x80, m4)
    7921
                mstore(0xa0, m5)
    7922
                mstore(0xc0, m6)
    7923
                mstore(0xe0, m7)
    7924
                mstore(0x100, m8)
    7925
            }
    7926
        }
    7927
    7928
        function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    7929
            bytes32 m0;
    7930
            bytes32 m1;
    7931
            bytes32 m2;
    7932
            bytes32 m3;
    7933
            bytes32 m4;
    7934
            bytes32 m5;
    7935
            bytes32 m6;
    7936
            bytes32 m7;
    7937
            bytes32 m8;
    7938
            /// @solidity memory-safe-assembly
    7939
            assembly {
    7940
                function writeString(pos, w) {
    7941
                    let length := 0
    7942
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7943
                    mstore(pos, length)
    7944
                    let shift := sub(256, shl(3, length))
    7945
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7946
                }
    7947
                m0 := mload(0x00)
    7948
                m1 := mload(0x20)
    7949
                m2 := mload(0x40)
    7950
                m3 := mload(0x60)
    7951
                m4 := mload(0x80)
    7952
                m5 := mload(0xa0)
    7953
                m6 := mload(0xc0)
    7954
                m7 := mload(0xe0)
    7955
                m8 := mload(0x100)
    7956
                // Selector of `log(bool,string,string,address)`.
    7957
                mstore(0x00, 0x97d394d8)
    7958
                mstore(0x20, p0)
    7959
                mstore(0x40, 0x80)
    7960
                mstore(0x60, 0xc0)
    7961
                mstore(0x80, p3)
    7962
                writeString(0xa0, p1)
    7963
                writeString(0xe0, p2)
    7964
            }
    7965
            _sendLogPayload(0x1c, 0x104);
    7966
            /// @solidity memory-safe-assembly
    7967
            assembly {
    7968
                mstore(0x00, m0)
    7969
                mstore(0x20, m1)
    7970
                mstore(0x40, m2)
    7971
                mstore(0x60, m3)
    7972
                mstore(0x80, m4)
    7973
                mstore(0xa0, m5)
    7974
                mstore(0xc0, m6)
    7975
                mstore(0xe0, m7)
    7976
                mstore(0x100, m8)
    7977
            }
    7978
        }
    7979
    7980
        function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    7981
            bytes32 m0;
    7982
            bytes32 m1;
    7983
            bytes32 m2;
    7984
            bytes32 m3;
    7985
            bytes32 m4;
    7986
            bytes32 m5;
    7987
            bytes32 m6;
    7988
            bytes32 m7;
    7989
            bytes32 m8;
    7990
            /// @solidity memory-safe-assembly
    7991
            assembly {
    7992
                function writeString(pos, w) {
    7993
                    let length := 0
    7994
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    7995
                    mstore(pos, length)
    7996
                    let shift := sub(256, shl(3, length))
    7997
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    7998
                }
    7999
                m0 := mload(0x00)
    8000
                m1 := mload(0x20)
    8001
                m2 := mload(0x40)
    8002
                m3 := mload(0x60)
    8003
                m4 := mload(0x80)
    8004
                m5 := mload(0xa0)
    8005
                m6 := mload(0xc0)
    8006
                m7 := mload(0xe0)
    8007
                m8 := mload(0x100)
    8008
                // Selector of `log(bool,string,string,bool)`.
    8009
                mstore(0x00, 0x1e4b87e5)
    8010
                mstore(0x20, p0)
    8011
                mstore(0x40, 0x80)
    8012
                mstore(0x60, 0xc0)
    8013
                mstore(0x80, p3)
    8014
                writeString(0xa0, p1)
    8015
                writeString(0xe0, p2)
    8016
            }
    8017
            _sendLogPayload(0x1c, 0x104);
    8018
            /// @solidity memory-safe-assembly
    8019
            assembly {
    8020
                mstore(0x00, m0)
    8021
                mstore(0x20, m1)
    8022
                mstore(0x40, m2)
    8023
                mstore(0x60, m3)
    8024
                mstore(0x80, m4)
    8025
                mstore(0xa0, m5)
    8026
                mstore(0xc0, m6)
    8027
                mstore(0xe0, m7)
    8028
                mstore(0x100, m8)
    8029
            }
    8030
        }
    8031
    8032
        function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    8033
            bytes32 m0;
    8034
            bytes32 m1;
    8035
            bytes32 m2;
    8036
            bytes32 m3;
    8037
            bytes32 m4;
    8038
            bytes32 m5;
    8039
            bytes32 m6;
    8040
            bytes32 m7;
    8041
            bytes32 m8;
    8042
            /// @solidity memory-safe-assembly
    8043
            assembly {
    8044
                function writeString(pos, w) {
    8045
                    let length := 0
    8046
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8047
                    mstore(pos, length)
    8048
                    let shift := sub(256, shl(3, length))
    8049
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8050
                }
    8051
                m0 := mload(0x00)
    8052
                m1 := mload(0x20)
    8053
                m2 := mload(0x40)
    8054
                m3 := mload(0x60)
    8055
                m4 := mload(0x80)
    8056
                m5 := mload(0xa0)
    8057
                m6 := mload(0xc0)
    8058
                m7 := mload(0xe0)
    8059
                m8 := mload(0x100)
    8060
                // Selector of `log(bool,string,string,uint256)`.
    8061
                mstore(0x00, 0x7be0c3eb)
    8062
                mstore(0x20, p0)
    8063
                mstore(0x40, 0x80)
    8064
                mstore(0x60, 0xc0)
    8065
                mstore(0x80, p3)
    8066
                writeString(0xa0, p1)
    8067
                writeString(0xe0, p2)
    8068
            }
    8069
            _sendLogPayload(0x1c, 0x104);
    8070
            /// @solidity memory-safe-assembly
    8071
            assembly {
    8072
                mstore(0x00, m0)
    8073
                mstore(0x20, m1)
    8074
                mstore(0x40, m2)
    8075
                mstore(0x60, m3)
    8076
                mstore(0x80, m4)
    8077
                mstore(0xa0, m5)
    8078
                mstore(0xc0, m6)
    8079
                mstore(0xe0, m7)
    8080
                mstore(0x100, m8)
    8081
            }
    8082
        }
    8083
    8084
        function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    8085
            bytes32 m0;
    8086
            bytes32 m1;
    8087
            bytes32 m2;
    8088
            bytes32 m3;
    8089
            bytes32 m4;
    8090
            bytes32 m5;
    8091
            bytes32 m6;
    8092
            bytes32 m7;
    8093
            bytes32 m8;
    8094
            bytes32 m9;
    8095
            bytes32 m10;
    8096
            /// @solidity memory-safe-assembly
    8097
            assembly {
    8098
                function writeString(pos, w) {
    8099
                    let length := 0
    8100
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8101
                    mstore(pos, length)
    8102
                    let shift := sub(256, shl(3, length))
    8103
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8104
                }
    8105
                m0 := mload(0x00)
    8106
                m1 := mload(0x20)
    8107
                m2 := mload(0x40)
    8108
                m3 := mload(0x60)
    8109
                m4 := mload(0x80)
    8110
                m5 := mload(0xa0)
    8111
                m6 := mload(0xc0)
    8112
                m7 := mload(0xe0)
    8113
                m8 := mload(0x100)
    8114
                m9 := mload(0x120)
    8115
                m10 := mload(0x140)
    8116
                // Selector of `log(bool,string,string,string)`.
    8117
                mstore(0x00, 0x1762e32a)
    8118
                mstore(0x20, p0)
    8119
                mstore(0x40, 0x80)
    8120
                mstore(0x60, 0xc0)
    8121
                mstore(0x80, 0x100)
    8122
                writeString(0xa0, p1)
    8123
                writeString(0xe0, p2)
    8124
                writeString(0x120, p3)
    8125
            }
    8126
            _sendLogPayload(0x1c, 0x144);
    8127
            /// @solidity memory-safe-assembly
    8128
            assembly {
    8129
                mstore(0x00, m0)
    8130
                mstore(0x20, m1)
    8131
                mstore(0x40, m2)
    8132
                mstore(0x60, m3)
    8133
                mstore(0x80, m4)
    8134
                mstore(0xa0, m5)
    8135
                mstore(0xc0, m6)
    8136
                mstore(0xe0, m7)
    8137
                mstore(0x100, m8)
    8138
                mstore(0x120, m9)
    8139
                mstore(0x140, m10)
    8140
            }
    8141
        }
    8142
    8143
        function log(uint256 p0, address p1, address p2, address p3) internal pure {
    8144
            bytes32 m0;
    8145
            bytes32 m1;
    8146
            bytes32 m2;
    8147
            bytes32 m3;
    8148
            bytes32 m4;
    8149
            /// @solidity memory-safe-assembly
    8150
            assembly {
    8151
                m0 := mload(0x00)
    8152
                m1 := mload(0x20)
    8153
                m2 := mload(0x40)
    8154
                m3 := mload(0x60)
    8155
                m4 := mload(0x80)
    8156
                // Selector of `log(uint256,address,address,address)`.
    8157
                mstore(0x00, 0x2488b414)
    8158
                mstore(0x20, p0)
    8159
                mstore(0x40, p1)
    8160
                mstore(0x60, p2)
    8161
                mstore(0x80, p3)
    8162
            }
    8163
            _sendLogPayload(0x1c, 0x84);
    8164
            /// @solidity memory-safe-assembly
    8165
            assembly {
    8166
                mstore(0x00, m0)
    8167
                mstore(0x20, m1)
    8168
                mstore(0x40, m2)
    8169
                mstore(0x60, m3)
    8170
                mstore(0x80, m4)
    8171
            }
    8172
        }
    8173
    8174
        function log(uint256 p0, address p1, address p2, bool p3) internal pure {
    8175
            bytes32 m0;
    8176
            bytes32 m1;
    8177
            bytes32 m2;
    8178
            bytes32 m3;
    8179
            bytes32 m4;
    8180
            /// @solidity memory-safe-assembly
    8181
            assembly {
    8182
                m0 := mload(0x00)
    8183
                m1 := mload(0x20)
    8184
                m2 := mload(0x40)
    8185
                m3 := mload(0x60)
    8186
                m4 := mload(0x80)
    8187
                // Selector of `log(uint256,address,address,bool)`.
    8188
                mstore(0x00, 0x091ffaf5)
    8189
                mstore(0x20, p0)
    8190
                mstore(0x40, p1)
    8191
                mstore(0x60, p2)
    8192
                mstore(0x80, p3)
    8193
            }
    8194
            _sendLogPayload(0x1c, 0x84);
    8195
            /// @solidity memory-safe-assembly
    8196
            assembly {
    8197
                mstore(0x00, m0)
    8198
                mstore(0x20, m1)
    8199
                mstore(0x40, m2)
    8200
                mstore(0x60, m3)
    8201
                mstore(0x80, m4)
    8202
            }
    8203
        }
    8204
    8205
        function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
    8206
            bytes32 m0;
    8207
            bytes32 m1;
    8208
            bytes32 m2;
    8209
            bytes32 m3;
    8210
            bytes32 m4;
    8211
            /// @solidity memory-safe-assembly
    8212
            assembly {
    8213
                m0 := mload(0x00)
    8214
                m1 := mload(0x20)
    8215
                m2 := mload(0x40)
    8216
                m3 := mload(0x60)
    8217
                m4 := mload(0x80)
    8218
                // Selector of `log(uint256,address,address,uint256)`.
    8219
                mstore(0x00, 0x736efbb6)
    8220
                mstore(0x20, p0)
    8221
                mstore(0x40, p1)
    8222
                mstore(0x60, p2)
    8223
                mstore(0x80, p3)
    8224
            }
    8225
            _sendLogPayload(0x1c, 0x84);
    8226
            /// @solidity memory-safe-assembly
    8227
            assembly {
    8228
                mstore(0x00, m0)
    8229
                mstore(0x20, m1)
    8230
                mstore(0x40, m2)
    8231
                mstore(0x60, m3)
    8232
                mstore(0x80, m4)
    8233
            }
    8234
        }
    8235
    8236
        function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {
    8237
            bytes32 m0;
    8238
            bytes32 m1;
    8239
            bytes32 m2;
    8240
            bytes32 m3;
    8241
            bytes32 m4;
    8242
            bytes32 m5;
    8243
            bytes32 m6;
    8244
            /// @solidity memory-safe-assembly
    8245
            assembly {
    8246
                function writeString(pos, w) {
    8247
                    let length := 0
    8248
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8249
                    mstore(pos, length)
    8250
                    let shift := sub(256, shl(3, length))
    8251
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8252
                }
    8253
                m0 := mload(0x00)
    8254
                m1 := mload(0x20)
    8255
                m2 := mload(0x40)
    8256
                m3 := mload(0x60)
    8257
                m4 := mload(0x80)
    8258
                m5 := mload(0xa0)
    8259
                m6 := mload(0xc0)
    8260
                // Selector of `log(uint256,address,address,string)`.
    8261
                mstore(0x00, 0x031c6f73)
    8262
                mstore(0x20, p0)
    8263
                mstore(0x40, p1)
    8264
                mstore(0x60, p2)
    8265
                mstore(0x80, 0x80)
    8266
                writeString(0xa0, p3)
    8267
            }
    8268
            _sendLogPayload(0x1c, 0xc4);
    8269
            /// @solidity memory-safe-assembly
    8270
            assembly {
    8271
                mstore(0x00, m0)
    8272
                mstore(0x20, m1)
    8273
                mstore(0x40, m2)
    8274
                mstore(0x60, m3)
    8275
                mstore(0x80, m4)
    8276
                mstore(0xa0, m5)
    8277
                mstore(0xc0, m6)
    8278
            }
    8279
        }
    8280
    8281
        function log(uint256 p0, address p1, bool p2, address p3) internal pure {
    8282
            bytes32 m0;
    8283
            bytes32 m1;
    8284
            bytes32 m2;
    8285
            bytes32 m3;
    8286
            bytes32 m4;
    8287
            /// @solidity memory-safe-assembly
    8288
            assembly {
    8289
                m0 := mload(0x00)
    8290
                m1 := mload(0x20)
    8291
                m2 := mload(0x40)
    8292
                m3 := mload(0x60)
    8293
                m4 := mload(0x80)
    8294
                // Selector of `log(uint256,address,bool,address)`.
    8295
                mstore(0x00, 0xef72c513)
    8296
                mstore(0x20, p0)
    8297
                mstore(0x40, p1)
    8298
                mstore(0x60, p2)
    8299
                mstore(0x80, p3)
    8300
            }
    8301
            _sendLogPayload(0x1c, 0x84);
    8302
            /// @solidity memory-safe-assembly
    8303
            assembly {
    8304
                mstore(0x00, m0)
    8305
                mstore(0x20, m1)
    8306
                mstore(0x40, m2)
    8307
                mstore(0x60, m3)
    8308
                mstore(0x80, m4)
    8309
            }
    8310
        }
    8311
    8312
        function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
    8313
            bytes32 m0;
    8314
            bytes32 m1;
    8315
            bytes32 m2;
    8316
            bytes32 m3;
    8317
            bytes32 m4;
    8318
            /// @solidity memory-safe-assembly
    8319
            assembly {
    8320
                m0 := mload(0x00)
    8321
                m1 := mload(0x20)
    8322
                m2 := mload(0x40)
    8323
                m3 := mload(0x60)
    8324
                m4 := mload(0x80)
    8325
                // Selector of `log(uint256,address,bool,bool)`.
    8326
                mstore(0x00, 0xe351140f)
    8327
                mstore(0x20, p0)
    8328
                mstore(0x40, p1)
    8329
                mstore(0x60, p2)
    8330
                mstore(0x80, p3)
    8331
            }
    8332
            _sendLogPayload(0x1c, 0x84);
    8333
            /// @solidity memory-safe-assembly
    8334
            assembly {
    8335
                mstore(0x00, m0)
    8336
                mstore(0x20, m1)
    8337
                mstore(0x40, m2)
    8338
                mstore(0x60, m3)
    8339
                mstore(0x80, m4)
    8340
            }
    8341
        }
    8342
    8343
        function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
    8344
            bytes32 m0;
    8345
            bytes32 m1;
    8346
            bytes32 m2;
    8347
            bytes32 m3;
    8348
            bytes32 m4;
    8349
            /// @solidity memory-safe-assembly
    8350
            assembly {
    8351
                m0 := mload(0x00)
    8352
                m1 := mload(0x20)
    8353
                m2 := mload(0x40)
    8354
                m3 := mload(0x60)
    8355
                m4 := mload(0x80)
    8356
                // Selector of `log(uint256,address,bool,uint256)`.
    8357
                mstore(0x00, 0x5abd992a)
    8358
                mstore(0x20, p0)
    8359
                mstore(0x40, p1)
    8360
                mstore(0x60, p2)
    8361
                mstore(0x80, p3)
    8362
            }
    8363
            _sendLogPayload(0x1c, 0x84);
    8364
            /// @solidity memory-safe-assembly
    8365
            assembly {
    8366
                mstore(0x00, m0)
    8367
                mstore(0x20, m1)
    8368
                mstore(0x40, m2)
    8369
                mstore(0x60, m3)
    8370
                mstore(0x80, m4)
    8371
            }
    8372
        }
    8373
    8374
        function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {
    8375
            bytes32 m0;
    8376
            bytes32 m1;
    8377
            bytes32 m2;
    8378
            bytes32 m3;
    8379
            bytes32 m4;
    8380
            bytes32 m5;
    8381
            bytes32 m6;
    8382
            /// @solidity memory-safe-assembly
    8383
            assembly {
    8384
                function writeString(pos, w) {
    8385
                    let length := 0
    8386
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8387
                    mstore(pos, length)
    8388
                    let shift := sub(256, shl(3, length))
    8389
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8390
                }
    8391
                m0 := mload(0x00)
    8392
                m1 := mload(0x20)
    8393
                m2 := mload(0x40)
    8394
                m3 := mload(0x60)
    8395
                m4 := mload(0x80)
    8396
                m5 := mload(0xa0)
    8397
                m6 := mload(0xc0)
    8398
                // Selector of `log(uint256,address,bool,string)`.
    8399
                mstore(0x00, 0x90fb06aa)
    8400
                mstore(0x20, p0)
    8401
                mstore(0x40, p1)
    8402
                mstore(0x60, p2)
    8403
                mstore(0x80, 0x80)
    8404
                writeString(0xa0, p3)
    8405
            }
    8406
            _sendLogPayload(0x1c, 0xc4);
    8407
            /// @solidity memory-safe-assembly
    8408
            assembly {
    8409
                mstore(0x00, m0)
    8410
                mstore(0x20, m1)
    8411
                mstore(0x40, m2)
    8412
                mstore(0x60, m3)
    8413
                mstore(0x80, m4)
    8414
                mstore(0xa0, m5)
    8415
                mstore(0xc0, m6)
    8416
            }
    8417
        }
    8418
    8419
        function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
    8420
            bytes32 m0;
    8421
            bytes32 m1;
    8422
            bytes32 m2;
    8423
            bytes32 m3;
    8424
            bytes32 m4;
    8425
            /// @solidity memory-safe-assembly
    8426
            assembly {
    8427
                m0 := mload(0x00)
    8428
                m1 := mload(0x20)
    8429
                m2 := mload(0x40)
    8430
                m3 := mload(0x60)
    8431
                m4 := mload(0x80)
    8432
                // Selector of `log(uint256,address,uint256,address)`.
    8433
                mstore(0x00, 0x15c127b5)
    8434
                mstore(0x20, p0)
    8435
                mstore(0x40, p1)
    8436
                mstore(0x60, p2)
    8437
                mstore(0x80, p3)
    8438
            }
    8439
            _sendLogPayload(0x1c, 0x84);
    8440
            /// @solidity memory-safe-assembly
    8441
            assembly {
    8442
                mstore(0x00, m0)
    8443
                mstore(0x20, m1)
    8444
                mstore(0x40, m2)
    8445
                mstore(0x60, m3)
    8446
                mstore(0x80, m4)
    8447
            }
    8448
        }
    8449
    8450
        function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
    8451
            bytes32 m0;
    8452
            bytes32 m1;
    8453
            bytes32 m2;
    8454
            bytes32 m3;
    8455
            bytes32 m4;
    8456
            /// @solidity memory-safe-assembly
    8457
            assembly {
    8458
                m0 := mload(0x00)
    8459
                m1 := mload(0x20)
    8460
                m2 := mload(0x40)
    8461
                m3 := mload(0x60)
    8462
                m4 := mload(0x80)
    8463
                // Selector of `log(uint256,address,uint256,bool)`.
    8464
                mstore(0x00, 0x5f743a7c)
    8465
                mstore(0x20, p0)
    8466
                mstore(0x40, p1)
    8467
                mstore(0x60, p2)
    8468
                mstore(0x80, p3)
    8469
            }
    8470
            _sendLogPayload(0x1c, 0x84);
    8471
            /// @solidity memory-safe-assembly
    8472
            assembly {
    8473
                mstore(0x00, m0)
    8474
                mstore(0x20, m1)
    8475
                mstore(0x40, m2)
    8476
                mstore(0x60, m3)
    8477
                mstore(0x80, m4)
    8478
            }
    8479
        }
    8480
    8481
        function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
    8482
            bytes32 m0;
    8483
            bytes32 m1;
    8484
            bytes32 m2;
    8485
            bytes32 m3;
    8486
            bytes32 m4;
    8487
            /// @solidity memory-safe-assembly
    8488
            assembly {
    8489
                m0 := mload(0x00)
    8490
                m1 := mload(0x20)
    8491
                m2 := mload(0x40)
    8492
                m3 := mload(0x60)
    8493
                m4 := mload(0x80)
    8494
                // Selector of `log(uint256,address,uint256,uint256)`.
    8495
                mstore(0x00, 0x0c9cd9c1)
    8496
                mstore(0x20, p0)
    8497
                mstore(0x40, p1)
    8498
                mstore(0x60, p2)
    8499
                mstore(0x80, p3)
    8500
            }
    8501
            _sendLogPayload(0x1c, 0x84);
    8502
            /// @solidity memory-safe-assembly
    8503
            assembly {
    8504
                mstore(0x00, m0)
    8505
                mstore(0x20, m1)
    8506
                mstore(0x40, m2)
    8507
                mstore(0x60, m3)
    8508
                mstore(0x80, m4)
    8509
            }
    8510
        }
    8511
    8512
        function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    8513
            bytes32 m0;
    8514
            bytes32 m1;
    8515
            bytes32 m2;
    8516
            bytes32 m3;
    8517
            bytes32 m4;
    8518
            bytes32 m5;
    8519
            bytes32 m6;
    8520
            /// @solidity memory-safe-assembly
    8521
            assembly {
    8522
                function writeString(pos, w) {
    8523
                    let length := 0
    8524
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8525
                    mstore(pos, length)
    8526
                    let shift := sub(256, shl(3, length))
    8527
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8528
                }
    8529
                m0 := mload(0x00)
    8530
                m1 := mload(0x20)
    8531
                m2 := mload(0x40)
    8532
                m3 := mload(0x60)
    8533
                m4 := mload(0x80)
    8534
                m5 := mload(0xa0)
    8535
                m6 := mload(0xc0)
    8536
                // Selector of `log(uint256,address,uint256,string)`.
    8537
                mstore(0x00, 0xddb06521)
    8538
                mstore(0x20, p0)
    8539
                mstore(0x40, p1)
    8540
                mstore(0x60, p2)
    8541
                mstore(0x80, 0x80)
    8542
                writeString(0xa0, p3)
    8543
            }
    8544
            _sendLogPayload(0x1c, 0xc4);
    8545
            /// @solidity memory-safe-assembly
    8546
            assembly {
    8547
                mstore(0x00, m0)
    8548
                mstore(0x20, m1)
    8549
                mstore(0x40, m2)
    8550
                mstore(0x60, m3)
    8551
                mstore(0x80, m4)
    8552
                mstore(0xa0, m5)
    8553
                mstore(0xc0, m6)
    8554
            }
    8555
        }
    8556
    8557
        function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {
    8558
            bytes32 m0;
    8559
            bytes32 m1;
    8560
            bytes32 m2;
    8561
            bytes32 m3;
    8562
            bytes32 m4;
    8563
            bytes32 m5;
    8564
            bytes32 m6;
    8565
            /// @solidity memory-safe-assembly
    8566
            assembly {
    8567
                function writeString(pos, w) {
    8568
                    let length := 0
    8569
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8570
                    mstore(pos, length)
    8571
                    let shift := sub(256, shl(3, length))
    8572
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8573
                }
    8574
                m0 := mload(0x00)
    8575
                m1 := mload(0x20)
    8576
                m2 := mload(0x40)
    8577
                m3 := mload(0x60)
    8578
                m4 := mload(0x80)
    8579
                m5 := mload(0xa0)
    8580
                m6 := mload(0xc0)
    8581
                // Selector of `log(uint256,address,string,address)`.
    8582
                mstore(0x00, 0x9cba8fff)
    8583
                mstore(0x20, p0)
    8584
                mstore(0x40, p1)
    8585
                mstore(0x60, 0x80)
    8586
                mstore(0x80, p3)
    8587
                writeString(0xa0, p2)
    8588
            }
    8589
            _sendLogPayload(0x1c, 0xc4);
    8590
            /// @solidity memory-safe-assembly
    8591
            assembly {
    8592
                mstore(0x00, m0)
    8593
                mstore(0x20, m1)
    8594
                mstore(0x40, m2)
    8595
                mstore(0x60, m3)
    8596
                mstore(0x80, m4)
    8597
                mstore(0xa0, m5)
    8598
                mstore(0xc0, m6)
    8599
            }
    8600
        }
    8601
    8602
        function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {
    8603
            bytes32 m0;
    8604
            bytes32 m1;
    8605
            bytes32 m2;
    8606
            bytes32 m3;
    8607
            bytes32 m4;
    8608
            bytes32 m5;
    8609
            bytes32 m6;
    8610
            /// @solidity memory-safe-assembly
    8611
            assembly {
    8612
                function writeString(pos, w) {
    8613
                    let length := 0
    8614
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8615
                    mstore(pos, length)
    8616
                    let shift := sub(256, shl(3, length))
    8617
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8618
                }
    8619
                m0 := mload(0x00)
    8620
                m1 := mload(0x20)
    8621
                m2 := mload(0x40)
    8622
                m3 := mload(0x60)
    8623
                m4 := mload(0x80)
    8624
                m5 := mload(0xa0)
    8625
                m6 := mload(0xc0)
    8626
                // Selector of `log(uint256,address,string,bool)`.
    8627
                mstore(0x00, 0xcc32ab07)
    8628
                mstore(0x20, p0)
    8629
                mstore(0x40, p1)
    8630
                mstore(0x60, 0x80)
    8631
                mstore(0x80, p3)
    8632
                writeString(0xa0, p2)
    8633
            }
    8634
            _sendLogPayload(0x1c, 0xc4);
    8635
            /// @solidity memory-safe-assembly
    8636
            assembly {
    8637
                mstore(0x00, m0)
    8638
                mstore(0x20, m1)
    8639
                mstore(0x40, m2)
    8640
                mstore(0x60, m3)
    8641
                mstore(0x80, m4)
    8642
                mstore(0xa0, m5)
    8643
                mstore(0xc0, m6)
    8644
            }
    8645
        }
    8646
    8647
        function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    8648
            bytes32 m0;
    8649
            bytes32 m1;
    8650
            bytes32 m2;
    8651
            bytes32 m3;
    8652
            bytes32 m4;
    8653
            bytes32 m5;
    8654
            bytes32 m6;
    8655
            /// @solidity memory-safe-assembly
    8656
            assembly {
    8657
                function writeString(pos, w) {
    8658
                    let length := 0
    8659
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8660
                    mstore(pos, length)
    8661
                    let shift := sub(256, shl(3, length))
    8662
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8663
                }
    8664
                m0 := mload(0x00)
    8665
                m1 := mload(0x20)
    8666
                m2 := mload(0x40)
    8667
                m3 := mload(0x60)
    8668
                m4 := mload(0x80)
    8669
                m5 := mload(0xa0)
    8670
                m6 := mload(0xc0)
    8671
                // Selector of `log(uint256,address,string,uint256)`.
    8672
                mstore(0x00, 0x46826b5d)
    8673
                mstore(0x20, p0)
    8674
                mstore(0x40, p1)
    8675
                mstore(0x60, 0x80)
    8676
                mstore(0x80, p3)
    8677
                writeString(0xa0, p2)
    8678
            }
    8679
            _sendLogPayload(0x1c, 0xc4);
    8680
            /// @solidity memory-safe-assembly
    8681
            assembly {
    8682
                mstore(0x00, m0)
    8683
                mstore(0x20, m1)
    8684
                mstore(0x40, m2)
    8685
                mstore(0x60, m3)
    8686
                mstore(0x80, m4)
    8687
                mstore(0xa0, m5)
    8688
                mstore(0xc0, m6)
    8689
            }
    8690
        }
    8691
    8692
        function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    8693
            bytes32 m0;
    8694
            bytes32 m1;
    8695
            bytes32 m2;
    8696
            bytes32 m3;
    8697
            bytes32 m4;
    8698
            bytes32 m5;
    8699
            bytes32 m6;
    8700
            bytes32 m7;
    8701
            bytes32 m8;
    8702
            /// @solidity memory-safe-assembly
    8703
            assembly {
    8704
                function writeString(pos, w) {
    8705
                    let length := 0
    8706
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8707
                    mstore(pos, length)
    8708
                    let shift := sub(256, shl(3, length))
    8709
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8710
                }
    8711
                m0 := mload(0x00)
    8712
                m1 := mload(0x20)
    8713
                m2 := mload(0x40)
    8714
                m3 := mload(0x60)
    8715
                m4 := mload(0x80)
    8716
                m5 := mload(0xa0)
    8717
                m6 := mload(0xc0)
    8718
                m7 := mload(0xe0)
    8719
                m8 := mload(0x100)
    8720
                // Selector of `log(uint256,address,string,string)`.
    8721
                mstore(0x00, 0x3e128ca3)
    8722
                mstore(0x20, p0)
    8723
                mstore(0x40, p1)
    8724
                mstore(0x60, 0x80)
    8725
                mstore(0x80, 0xc0)
    8726
                writeString(0xa0, p2)
    8727
                writeString(0xe0, p3)
    8728
            }
    8729
            _sendLogPayload(0x1c, 0x104);
    8730
            /// @solidity memory-safe-assembly
    8731
            assembly {
    8732
                mstore(0x00, m0)
    8733
                mstore(0x20, m1)
    8734
                mstore(0x40, m2)
    8735
                mstore(0x60, m3)
    8736
                mstore(0x80, m4)
    8737
                mstore(0xa0, m5)
    8738
                mstore(0xc0, m6)
    8739
                mstore(0xe0, m7)
    8740
                mstore(0x100, m8)
    8741
            }
    8742
        }
    8743
    8744
        function log(uint256 p0, bool p1, address p2, address p3) internal pure {
    8745
            bytes32 m0;
    8746
            bytes32 m1;
    8747
            bytes32 m2;
    8748
            bytes32 m3;
    8749
            bytes32 m4;
    8750
            /// @solidity memory-safe-assembly
    8751
            assembly {
    8752
                m0 := mload(0x00)
    8753
                m1 := mload(0x20)
    8754
                m2 := mload(0x40)
    8755
                m3 := mload(0x60)
    8756
                m4 := mload(0x80)
    8757
                // Selector of `log(uint256,bool,address,address)`.
    8758
                mstore(0x00, 0xa1ef4cbb)
    8759
                mstore(0x20, p0)
    8760
                mstore(0x40, p1)
    8761
                mstore(0x60, p2)
    8762
                mstore(0x80, p3)
    8763
            }
    8764
            _sendLogPayload(0x1c, 0x84);
    8765
            /// @solidity memory-safe-assembly
    8766
            assembly {
    8767
                mstore(0x00, m0)
    8768
                mstore(0x20, m1)
    8769
                mstore(0x40, m2)
    8770
                mstore(0x60, m3)
    8771
                mstore(0x80, m4)
    8772
            }
    8773
        }
    8774
    8775
        function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
    8776
            bytes32 m0;
    8777
            bytes32 m1;
    8778
            bytes32 m2;
    8779
            bytes32 m3;
    8780
            bytes32 m4;
    8781
            /// @solidity memory-safe-assembly
    8782
            assembly {
    8783
                m0 := mload(0x00)
    8784
                m1 := mload(0x20)
    8785
                m2 := mload(0x40)
    8786
                m3 := mload(0x60)
    8787
                m4 := mload(0x80)
    8788
                // Selector of `log(uint256,bool,address,bool)`.
    8789
                mstore(0x00, 0x454d54a5)
    8790
                mstore(0x20, p0)
    8791
                mstore(0x40, p1)
    8792
                mstore(0x60, p2)
    8793
                mstore(0x80, p3)
    8794
            }
    8795
            _sendLogPayload(0x1c, 0x84);
    8796
            /// @solidity memory-safe-assembly
    8797
            assembly {
    8798
                mstore(0x00, m0)
    8799
                mstore(0x20, m1)
    8800
                mstore(0x40, m2)
    8801
                mstore(0x60, m3)
    8802
                mstore(0x80, m4)
    8803
            }
    8804
        }
    8805
    8806
        function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
    8807
            bytes32 m0;
    8808
            bytes32 m1;
    8809
            bytes32 m2;
    8810
            bytes32 m3;
    8811
            bytes32 m4;
    8812
            /// @solidity memory-safe-assembly
    8813
            assembly {
    8814
                m0 := mload(0x00)
    8815
                m1 := mload(0x20)
    8816
                m2 := mload(0x40)
    8817
                m3 := mload(0x60)
    8818
                m4 := mload(0x80)
    8819
                // Selector of `log(uint256,bool,address,uint256)`.
    8820
                mstore(0x00, 0x078287f5)
    8821
                mstore(0x20, p0)
    8822
                mstore(0x40, p1)
    8823
                mstore(0x60, p2)
    8824
                mstore(0x80, p3)
    8825
            }
    8826
            _sendLogPayload(0x1c, 0x84);
    8827
            /// @solidity memory-safe-assembly
    8828
            assembly {
    8829
                mstore(0x00, m0)
    8830
                mstore(0x20, m1)
    8831
                mstore(0x40, m2)
    8832
                mstore(0x60, m3)
    8833
                mstore(0x80, m4)
    8834
            }
    8835
        }
    8836
    8837
        function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {
    8838
            bytes32 m0;
    8839
            bytes32 m1;
    8840
            bytes32 m2;
    8841
            bytes32 m3;
    8842
            bytes32 m4;
    8843
            bytes32 m5;
    8844
            bytes32 m6;
    8845
            /// @solidity memory-safe-assembly
    8846
            assembly {
    8847
                function writeString(pos, w) {
    8848
                    let length := 0
    8849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8850
                    mstore(pos, length)
    8851
                    let shift := sub(256, shl(3, length))
    8852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8853
                }
    8854
                m0 := mload(0x00)
    8855
                m1 := mload(0x20)
    8856
                m2 := mload(0x40)
    8857
                m3 := mload(0x60)
    8858
                m4 := mload(0x80)
    8859
                m5 := mload(0xa0)
    8860
                m6 := mload(0xc0)
    8861
                // Selector of `log(uint256,bool,address,string)`.
    8862
                mstore(0x00, 0xade052c7)
    8863
                mstore(0x20, p0)
    8864
                mstore(0x40, p1)
    8865
                mstore(0x60, p2)
    8866
                mstore(0x80, 0x80)
    8867
                writeString(0xa0, p3)
    8868
            }
    8869
            _sendLogPayload(0x1c, 0xc4);
    8870
            /// @solidity memory-safe-assembly
    8871
            assembly {
    8872
                mstore(0x00, m0)
    8873
                mstore(0x20, m1)
    8874
                mstore(0x40, m2)
    8875
                mstore(0x60, m3)
    8876
                mstore(0x80, m4)
    8877
                mstore(0xa0, m5)
    8878
                mstore(0xc0, m6)
    8879
            }
    8880
        }
    8881
    8882
        function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
    8883
            bytes32 m0;
    8884
            bytes32 m1;
    8885
            bytes32 m2;
    8886
            bytes32 m3;
    8887
            bytes32 m4;
    8888
            /// @solidity memory-safe-assembly
    8889
            assembly {
    8890
                m0 := mload(0x00)
    8891
                m1 := mload(0x20)
    8892
                m2 := mload(0x40)
    8893
                m3 := mload(0x60)
    8894
                m4 := mload(0x80)
    8895
                // Selector of `log(uint256,bool,bool,address)`.
    8896
                mstore(0x00, 0x69640b59)
    8897
                mstore(0x20, p0)
    8898
                mstore(0x40, p1)
    8899
                mstore(0x60, p2)
    8900
                mstore(0x80, p3)
    8901
            }
    8902
            _sendLogPayload(0x1c, 0x84);
    8903
            /// @solidity memory-safe-assembly
    8904
            assembly {
    8905
                mstore(0x00, m0)
    8906
                mstore(0x20, m1)
    8907
                mstore(0x40, m2)
    8908
                mstore(0x60, m3)
    8909
                mstore(0x80, m4)
    8910
            }
    8911
        }
    8912
    8913
        function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
    8914
            bytes32 m0;
    8915
            bytes32 m1;
    8916
            bytes32 m2;
    8917
            bytes32 m3;
    8918
            bytes32 m4;
    8919
            /// @solidity memory-safe-assembly
    8920
            assembly {
    8921
                m0 := mload(0x00)
    8922
                m1 := mload(0x20)
    8923
                m2 := mload(0x40)
    8924
                m3 := mload(0x60)
    8925
                m4 := mload(0x80)
    8926
                // Selector of `log(uint256,bool,bool,bool)`.
    8927
                mstore(0x00, 0xb6f577a1)
    8928
                mstore(0x20, p0)
    8929
                mstore(0x40, p1)
    8930
                mstore(0x60, p2)
    8931
                mstore(0x80, p3)
    8932
            }
    8933
            _sendLogPayload(0x1c, 0x84);
    8934
            /// @solidity memory-safe-assembly
    8935
            assembly {
    8936
                mstore(0x00, m0)
    8937
                mstore(0x20, m1)
    8938
                mstore(0x40, m2)
    8939
                mstore(0x60, m3)
    8940
                mstore(0x80, m4)
    8941
            }
    8942
        }
    8943
    8944
        function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
    8945
            bytes32 m0;
    8946
            bytes32 m1;
    8947
            bytes32 m2;
    8948
            bytes32 m3;
    8949
            bytes32 m4;
    8950
            /// @solidity memory-safe-assembly
    8951
            assembly {
    8952
                m0 := mload(0x00)
    8953
                m1 := mload(0x20)
    8954
                m2 := mload(0x40)
    8955
                m3 := mload(0x60)
    8956
                m4 := mload(0x80)
    8957
                // Selector of `log(uint256,bool,bool,uint256)`.
    8958
                mstore(0x00, 0x7464ce23)
    8959
                mstore(0x20, p0)
    8960
                mstore(0x40, p1)
    8961
                mstore(0x60, p2)
    8962
                mstore(0x80, p3)
    8963
            }
    8964
            _sendLogPayload(0x1c, 0x84);
    8965
            /// @solidity memory-safe-assembly
    8966
            assembly {
    8967
                mstore(0x00, m0)
    8968
                mstore(0x20, m1)
    8969
                mstore(0x40, m2)
    8970
                mstore(0x60, m3)
    8971
                mstore(0x80, m4)
    8972
            }
    8973
        }
    8974
    8975
        function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {
    8976
            bytes32 m0;
    8977
            bytes32 m1;
    8978
            bytes32 m2;
    8979
            bytes32 m3;
    8980
            bytes32 m4;
    8981
            bytes32 m5;
    8982
            bytes32 m6;
    8983
            /// @solidity memory-safe-assembly
    8984
            assembly {
    8985
                function writeString(pos, w) {
    8986
                    let length := 0
    8987
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    8988
                    mstore(pos, length)
    8989
                    let shift := sub(256, shl(3, length))
    8990
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    8991
                }
    8992
                m0 := mload(0x00)
    8993
                m1 := mload(0x20)
    8994
                m2 := mload(0x40)
    8995
                m3 := mload(0x60)
    8996
                m4 := mload(0x80)
    8997
                m5 := mload(0xa0)
    8998
                m6 := mload(0xc0)
    8999
                // Selector of `log(uint256,bool,bool,string)`.
    9000
                mstore(0x00, 0xdddb9561)
    9001
                mstore(0x20, p0)
    9002
                mstore(0x40, p1)
    9003
                mstore(0x60, p2)
    9004
                mstore(0x80, 0x80)
    9005
                writeString(0xa0, p3)
    9006
            }
    9007
            _sendLogPayload(0x1c, 0xc4);
    9008
            /// @solidity memory-safe-assembly
    9009
            assembly {
    9010
                mstore(0x00, m0)
    9011
                mstore(0x20, m1)
    9012
                mstore(0x40, m2)
    9013
                mstore(0x60, m3)
    9014
                mstore(0x80, m4)
    9015
                mstore(0xa0, m5)
    9016
                mstore(0xc0, m6)
    9017
            }
    9018
        }
    9019
    9020
        function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
    9021
            bytes32 m0;
    9022
            bytes32 m1;
    9023
            bytes32 m2;
    9024
            bytes32 m3;
    9025
            bytes32 m4;
    9026
            /// @solidity memory-safe-assembly
    9027
            assembly {
    9028
                m0 := mload(0x00)
    9029
                m1 := mload(0x20)
    9030
                m2 := mload(0x40)
    9031
                m3 := mload(0x60)
    9032
                m4 := mload(0x80)
    9033
                // Selector of `log(uint256,bool,uint256,address)`.
    9034
                mstore(0x00, 0x88cb6041)
    9035
                mstore(0x20, p0)
    9036
                mstore(0x40, p1)
    9037
                mstore(0x60, p2)
    9038
                mstore(0x80, p3)
    9039
            }
    9040
            _sendLogPayload(0x1c, 0x84);
    9041
            /// @solidity memory-safe-assembly
    9042
            assembly {
    9043
                mstore(0x00, m0)
    9044
                mstore(0x20, m1)
    9045
                mstore(0x40, m2)
    9046
                mstore(0x60, m3)
    9047
                mstore(0x80, m4)
    9048
            }
    9049
        }
    9050
    9051
        function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
    9052
            bytes32 m0;
    9053
            bytes32 m1;
    9054
            bytes32 m2;
    9055
            bytes32 m3;
    9056
            bytes32 m4;
    9057
            /// @solidity memory-safe-assembly
    9058
            assembly {
    9059
                m0 := mload(0x00)
    9060
                m1 := mload(0x20)
    9061
                m2 := mload(0x40)
    9062
                m3 := mload(0x60)
    9063
                m4 := mload(0x80)
    9064
                // Selector of `log(uint256,bool,uint256,bool)`.
    9065
                mstore(0x00, 0x91a02e2a)
    9066
                mstore(0x20, p0)
    9067
                mstore(0x40, p1)
    9068
                mstore(0x60, p2)
    9069
                mstore(0x80, p3)
    9070
            }
    9071
            _sendLogPayload(0x1c, 0x84);
    9072
            /// @solidity memory-safe-assembly
    9073
            assembly {
    9074
                mstore(0x00, m0)
    9075
                mstore(0x20, m1)
    9076
                mstore(0x40, m2)
    9077
                mstore(0x60, m3)
    9078
                mstore(0x80, m4)
    9079
            }
    9080
        }
    9081
    9082
        function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    9083
            bytes32 m0;
    9084
            bytes32 m1;
    9085
            bytes32 m2;
    9086
            bytes32 m3;
    9087
            bytes32 m4;
    9088
            /// @solidity memory-safe-assembly
    9089
            assembly {
    9090
                m0 := mload(0x00)
    9091
                m1 := mload(0x20)
    9092
                m2 := mload(0x40)
    9093
                m3 := mload(0x60)
    9094
                m4 := mload(0x80)
    9095
                // Selector of `log(uint256,bool,uint256,uint256)`.
    9096
                mstore(0x00, 0xc6acc7a8)
    9097
                mstore(0x20, p0)
    9098
                mstore(0x40, p1)
    9099
                mstore(0x60, p2)
    9100
                mstore(0x80, p3)
    9101
            }
    9102
            _sendLogPayload(0x1c, 0x84);
    9103
            /// @solidity memory-safe-assembly
    9104
            assembly {
    9105
                mstore(0x00, m0)
    9106
                mstore(0x20, m1)
    9107
                mstore(0x40, m2)
    9108
                mstore(0x60, m3)
    9109
                mstore(0x80, m4)
    9110
            }
    9111
        }
    9112
    9113
        function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    9114
            bytes32 m0;
    9115
            bytes32 m1;
    9116
            bytes32 m2;
    9117
            bytes32 m3;
    9118
            bytes32 m4;
    9119
            bytes32 m5;
    9120
            bytes32 m6;
    9121
            /// @solidity memory-safe-assembly
    9122
            assembly {
    9123
                function writeString(pos, w) {
    9124
                    let length := 0
    9125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9126
                    mstore(pos, length)
    9127
                    let shift := sub(256, shl(3, length))
    9128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9129
                }
    9130
                m0 := mload(0x00)
    9131
                m1 := mload(0x20)
    9132
                m2 := mload(0x40)
    9133
                m3 := mload(0x60)
    9134
                m4 := mload(0x80)
    9135
                m5 := mload(0xa0)
    9136
                m6 := mload(0xc0)
    9137
                // Selector of `log(uint256,bool,uint256,string)`.
    9138
                mstore(0x00, 0xde03e774)
    9139
                mstore(0x20, p0)
    9140
                mstore(0x40, p1)
    9141
                mstore(0x60, p2)
    9142
                mstore(0x80, 0x80)
    9143
                writeString(0xa0, p3)
    9144
            }
    9145
            _sendLogPayload(0x1c, 0xc4);
    9146
            /// @solidity memory-safe-assembly
    9147
            assembly {
    9148
                mstore(0x00, m0)
    9149
                mstore(0x20, m1)
    9150
                mstore(0x40, m2)
    9151
                mstore(0x60, m3)
    9152
                mstore(0x80, m4)
    9153
                mstore(0xa0, m5)
    9154
                mstore(0xc0, m6)
    9155
            }
    9156
        }
    9157
    9158
        function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {
    9159
            bytes32 m0;
    9160
            bytes32 m1;
    9161
            bytes32 m2;
    9162
            bytes32 m3;
    9163
            bytes32 m4;
    9164
            bytes32 m5;
    9165
            bytes32 m6;
    9166
            /// @solidity memory-safe-assembly
    9167
            assembly {
    9168
                function writeString(pos, w) {
    9169
                    let length := 0
    9170
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9171
                    mstore(pos, length)
    9172
                    let shift := sub(256, shl(3, length))
    9173
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9174
                }
    9175
                m0 := mload(0x00)
    9176
                m1 := mload(0x20)
    9177
                m2 := mload(0x40)
    9178
                m3 := mload(0x60)
    9179
                m4 := mload(0x80)
    9180
                m5 := mload(0xa0)
    9181
                m6 := mload(0xc0)
    9182
                // Selector of `log(uint256,bool,string,address)`.
    9183
                mstore(0x00, 0xef529018)
    9184
                mstore(0x20, p0)
    9185
                mstore(0x40, p1)
    9186
                mstore(0x60, 0x80)
    9187
                mstore(0x80, p3)
    9188
                writeString(0xa0, p2)
    9189
            }
    9190
            _sendLogPayload(0x1c, 0xc4);
    9191
            /// @solidity memory-safe-assembly
    9192
            assembly {
    9193
                mstore(0x00, m0)
    9194
                mstore(0x20, m1)
    9195
                mstore(0x40, m2)
    9196
                mstore(0x60, m3)
    9197
                mstore(0x80, m4)
    9198
                mstore(0xa0, m5)
    9199
                mstore(0xc0, m6)
    9200
            }
    9201
        }
    9202
    9203
        function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {
    9204
            bytes32 m0;
    9205
            bytes32 m1;
    9206
            bytes32 m2;
    9207
            bytes32 m3;
    9208
            bytes32 m4;
    9209
            bytes32 m5;
    9210
            bytes32 m6;
    9211
            /// @solidity memory-safe-assembly
    9212
            assembly {
    9213
                function writeString(pos, w) {
    9214
                    let length := 0
    9215
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9216
                    mstore(pos, length)
    9217
                    let shift := sub(256, shl(3, length))
    9218
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9219
                }
    9220
                m0 := mload(0x00)
    9221
                m1 := mload(0x20)
    9222
                m2 := mload(0x40)
    9223
                m3 := mload(0x60)
    9224
                m4 := mload(0x80)
    9225
                m5 := mload(0xa0)
    9226
                m6 := mload(0xc0)
    9227
                // Selector of `log(uint256,bool,string,bool)`.
    9228
                mstore(0x00, 0xeb928d7f)
    9229
                mstore(0x20, p0)
    9230
                mstore(0x40, p1)
    9231
                mstore(0x60, 0x80)
    9232
                mstore(0x80, p3)
    9233
                writeString(0xa0, p2)
    9234
            }
    9235
            _sendLogPayload(0x1c, 0xc4);
    9236
            /// @solidity memory-safe-assembly
    9237
            assembly {
    9238
                mstore(0x00, m0)
    9239
                mstore(0x20, m1)
    9240
                mstore(0x40, m2)
    9241
                mstore(0x60, m3)
    9242
                mstore(0x80, m4)
    9243
                mstore(0xa0, m5)
    9244
                mstore(0xc0, m6)
    9245
            }
    9246
        }
    9247
    9248
        function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    9249
            bytes32 m0;
    9250
            bytes32 m1;
    9251
            bytes32 m2;
    9252
            bytes32 m3;
    9253
            bytes32 m4;
    9254
            bytes32 m5;
    9255
            bytes32 m6;
    9256
            /// @solidity memory-safe-assembly
    9257
            assembly {
    9258
                function writeString(pos, w) {
    9259
                    let length := 0
    9260
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9261
                    mstore(pos, length)
    9262
                    let shift := sub(256, shl(3, length))
    9263
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9264
                }
    9265
                m0 := mload(0x00)
    9266
                m1 := mload(0x20)
    9267
                m2 := mload(0x40)
    9268
                m3 := mload(0x60)
    9269
                m4 := mload(0x80)
    9270
                m5 := mload(0xa0)
    9271
                m6 := mload(0xc0)
    9272
                // Selector of `log(uint256,bool,string,uint256)`.
    9273
                mstore(0x00, 0x2c1d0746)
    9274
                mstore(0x20, p0)
    9275
                mstore(0x40, p1)
    9276
                mstore(0x60, 0x80)
    9277
                mstore(0x80, p3)
    9278
                writeString(0xa0, p2)
    9279
            }
    9280
            _sendLogPayload(0x1c, 0xc4);
    9281
            /// @solidity memory-safe-assembly
    9282
            assembly {
    9283
                mstore(0x00, m0)
    9284
                mstore(0x20, m1)
    9285
                mstore(0x40, m2)
    9286
                mstore(0x60, m3)
    9287
                mstore(0x80, m4)
    9288
                mstore(0xa0, m5)
    9289
                mstore(0xc0, m6)
    9290
            }
    9291
        }
    9292
    9293
        function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    9294
            bytes32 m0;
    9295
            bytes32 m1;
    9296
            bytes32 m2;
    9297
            bytes32 m3;
    9298
            bytes32 m4;
    9299
            bytes32 m5;
    9300
            bytes32 m6;
    9301
            bytes32 m7;
    9302
            bytes32 m8;
    9303
            /// @solidity memory-safe-assembly
    9304
            assembly {
    9305
                function writeString(pos, w) {
    9306
                    let length := 0
    9307
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9308
                    mstore(pos, length)
    9309
                    let shift := sub(256, shl(3, length))
    9310
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9311
                }
    9312
                m0 := mload(0x00)
    9313
                m1 := mload(0x20)
    9314
                m2 := mload(0x40)
    9315
                m3 := mload(0x60)
    9316
                m4 := mload(0x80)
    9317
                m5 := mload(0xa0)
    9318
                m6 := mload(0xc0)
    9319
                m7 := mload(0xe0)
    9320
                m8 := mload(0x100)
    9321
                // Selector of `log(uint256,bool,string,string)`.
    9322
                mstore(0x00, 0x68c8b8bd)
    9323
                mstore(0x20, p0)
    9324
                mstore(0x40, p1)
    9325
                mstore(0x60, 0x80)
    9326
                mstore(0x80, 0xc0)
    9327
                writeString(0xa0, p2)
    9328
                writeString(0xe0, p3)
    9329
            }
    9330
            _sendLogPayload(0x1c, 0x104);
    9331
            /// @solidity memory-safe-assembly
    9332
            assembly {
    9333
                mstore(0x00, m0)
    9334
                mstore(0x20, m1)
    9335
                mstore(0x40, m2)
    9336
                mstore(0x60, m3)
    9337
                mstore(0x80, m4)
    9338
                mstore(0xa0, m5)
    9339
                mstore(0xc0, m6)
    9340
                mstore(0xe0, m7)
    9341
                mstore(0x100, m8)
    9342
            }
    9343
        }
    9344
    9345
        function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
    9346
            bytes32 m0;
    9347
            bytes32 m1;
    9348
            bytes32 m2;
    9349
            bytes32 m3;
    9350
            bytes32 m4;
    9351
            /// @solidity memory-safe-assembly
    9352
            assembly {
    9353
                m0 := mload(0x00)
    9354
                m1 := mload(0x20)
    9355
                m2 := mload(0x40)
    9356
                m3 := mload(0x60)
    9357
                m4 := mload(0x80)
    9358
                // Selector of `log(uint256,uint256,address,address)`.
    9359
                mstore(0x00, 0x56a5d1b1)
    9360
                mstore(0x20, p0)
    9361
                mstore(0x40, p1)
    9362
                mstore(0x60, p2)
    9363
                mstore(0x80, p3)
    9364
            }
    9365
            _sendLogPayload(0x1c, 0x84);
    9366
            /// @solidity memory-safe-assembly
    9367
            assembly {
    9368
                mstore(0x00, m0)
    9369
                mstore(0x20, m1)
    9370
                mstore(0x40, m2)
    9371
                mstore(0x60, m3)
    9372
                mstore(0x80, m4)
    9373
            }
    9374
        }
    9375
    9376
        function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
    9377
            bytes32 m0;
    9378
            bytes32 m1;
    9379
            bytes32 m2;
    9380
            bytes32 m3;
    9381
            bytes32 m4;
    9382
            /// @solidity memory-safe-assembly
    9383
            assembly {
    9384
                m0 := mload(0x00)
    9385
                m1 := mload(0x20)
    9386
                m2 := mload(0x40)
    9387
                m3 := mload(0x60)
    9388
                m4 := mload(0x80)
    9389
                // Selector of `log(uint256,uint256,address,bool)`.
    9390
                mstore(0x00, 0x15cac476)
    9391
                mstore(0x20, p0)
    9392
                mstore(0x40, p1)
    9393
                mstore(0x60, p2)
    9394
                mstore(0x80, p3)
    9395
            }
    9396
            _sendLogPayload(0x1c, 0x84);
    9397
            /// @solidity memory-safe-assembly
    9398
            assembly {
    9399
                mstore(0x00, m0)
    9400
                mstore(0x20, m1)
    9401
                mstore(0x40, m2)
    9402
                mstore(0x60, m3)
    9403
                mstore(0x80, m4)
    9404
            }
    9405
        }
    9406
    9407
        function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
    9408
            bytes32 m0;
    9409
            bytes32 m1;
    9410
            bytes32 m2;
    9411
            bytes32 m3;
    9412
            bytes32 m4;
    9413
            /// @solidity memory-safe-assembly
    9414
            assembly {
    9415
                m0 := mload(0x00)
    9416
                m1 := mload(0x20)
    9417
                m2 := mload(0x40)
    9418
                m3 := mload(0x60)
    9419
                m4 := mload(0x80)
    9420
                // Selector of `log(uint256,uint256,address,uint256)`.
    9421
                mstore(0x00, 0x88f6e4b2)
    9422
                mstore(0x20, p0)
    9423
                mstore(0x40, p1)
    9424
                mstore(0x60, p2)
    9425
                mstore(0x80, p3)
    9426
            }
    9427
            _sendLogPayload(0x1c, 0x84);
    9428
            /// @solidity memory-safe-assembly
    9429
            assembly {
    9430
                mstore(0x00, m0)
    9431
                mstore(0x20, m1)
    9432
                mstore(0x40, m2)
    9433
                mstore(0x60, m3)
    9434
                mstore(0x80, m4)
    9435
            }
    9436
        }
    9437
    9438
        function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    9439
            bytes32 m0;
    9440
            bytes32 m1;
    9441
            bytes32 m2;
    9442
            bytes32 m3;
    9443
            bytes32 m4;
    9444
            bytes32 m5;
    9445
            bytes32 m6;
    9446
            /// @solidity memory-safe-assembly
    9447
            assembly {
    9448
                function writeString(pos, w) {
    9449
                    let length := 0
    9450
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9451
                    mstore(pos, length)
    9452
                    let shift := sub(256, shl(3, length))
    9453
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9454
                }
    9455
                m0 := mload(0x00)
    9456
                m1 := mload(0x20)
    9457
                m2 := mload(0x40)
    9458
                m3 := mload(0x60)
    9459
                m4 := mload(0x80)
    9460
                m5 := mload(0xa0)
    9461
                m6 := mload(0xc0)
    9462
                // Selector of `log(uint256,uint256,address,string)`.
    9463
                mstore(0x00, 0x6cde40b8)
    9464
                mstore(0x20, p0)
    9465
                mstore(0x40, p1)
    9466
                mstore(0x60, p2)
    9467
                mstore(0x80, 0x80)
    9468
                writeString(0xa0, p3)
    9469
            }
    9470
            _sendLogPayload(0x1c, 0xc4);
    9471
            /// @solidity memory-safe-assembly
    9472
            assembly {
    9473
                mstore(0x00, m0)
    9474
                mstore(0x20, m1)
    9475
                mstore(0x40, m2)
    9476
                mstore(0x60, m3)
    9477
                mstore(0x80, m4)
    9478
                mstore(0xa0, m5)
    9479
                mstore(0xc0, m6)
    9480
            }
    9481
        }
    9482
    9483
        function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
    9484
            bytes32 m0;
    9485
            bytes32 m1;
    9486
            bytes32 m2;
    9487
            bytes32 m3;
    9488
            bytes32 m4;
    9489
            /// @solidity memory-safe-assembly
    9490
            assembly {
    9491
                m0 := mload(0x00)
    9492
                m1 := mload(0x20)
    9493
                m2 := mload(0x40)
    9494
                m3 := mload(0x60)
    9495
                m4 := mload(0x80)
    9496
                // Selector of `log(uint256,uint256,bool,address)`.
    9497
                mstore(0x00, 0x9a816a83)
    9498
                mstore(0x20, p0)
    9499
                mstore(0x40, p1)
    9500
                mstore(0x60, p2)
    9501
                mstore(0x80, p3)
    9502
            }
    9503
            _sendLogPayload(0x1c, 0x84);
    9504
            /// @solidity memory-safe-assembly
    9505
            assembly {
    9506
                mstore(0x00, m0)
    9507
                mstore(0x20, m1)
    9508
                mstore(0x40, m2)
    9509
                mstore(0x60, m3)
    9510
                mstore(0x80, m4)
    9511
            }
    9512
        }
    9513
    9514
        function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
    9515
            bytes32 m0;
    9516
            bytes32 m1;
    9517
            bytes32 m2;
    9518
            bytes32 m3;
    9519
            bytes32 m4;
    9520
            /// @solidity memory-safe-assembly
    9521
            assembly {
    9522
                m0 := mload(0x00)
    9523
                m1 := mload(0x20)
    9524
                m2 := mload(0x40)
    9525
                m3 := mload(0x60)
    9526
                m4 := mload(0x80)
    9527
                // Selector of `log(uint256,uint256,bool,bool)`.
    9528
                mstore(0x00, 0xab085ae6)
    9529
                mstore(0x20, p0)
    9530
                mstore(0x40, p1)
    9531
                mstore(0x60, p2)
    9532
                mstore(0x80, p3)
    9533
            }
    9534
            _sendLogPayload(0x1c, 0x84);
    9535
            /// @solidity memory-safe-assembly
    9536
            assembly {
    9537
                mstore(0x00, m0)
    9538
                mstore(0x20, m1)
    9539
                mstore(0x40, m2)
    9540
                mstore(0x60, m3)
    9541
                mstore(0x80, m4)
    9542
            }
    9543
        }
    9544
    9545
        function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    9546
            bytes32 m0;
    9547
            bytes32 m1;
    9548
            bytes32 m2;
    9549
            bytes32 m3;
    9550
            bytes32 m4;
    9551
            /// @solidity memory-safe-assembly
    9552
            assembly {
    9553
                m0 := mload(0x00)
    9554
                m1 := mload(0x20)
    9555
                m2 := mload(0x40)
    9556
                m3 := mload(0x60)
    9557
                m4 := mload(0x80)
    9558
                // Selector of `log(uint256,uint256,bool,uint256)`.
    9559
                mstore(0x00, 0xeb7f6fd2)
    9560
                mstore(0x20, p0)
    9561
                mstore(0x40, p1)
    9562
                mstore(0x60, p2)
    9563
                mstore(0x80, p3)
    9564
            }
    9565
            _sendLogPayload(0x1c, 0x84);
    9566
            /// @solidity memory-safe-assembly
    9567
            assembly {
    9568
                mstore(0x00, m0)
    9569
                mstore(0x20, m1)
    9570
                mstore(0x40, m2)
    9571
                mstore(0x60, m3)
    9572
                mstore(0x80, m4)
    9573
            }
    9574
        }
    9575
    9576
        function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    9577
            bytes32 m0;
    9578
            bytes32 m1;
    9579
            bytes32 m2;
    9580
            bytes32 m3;
    9581
            bytes32 m4;
    9582
            bytes32 m5;
    9583
            bytes32 m6;
    9584
            /// @solidity memory-safe-assembly
    9585
            assembly {
    9586
                function writeString(pos, w) {
    9587
                    let length := 0
    9588
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9589
                    mstore(pos, length)
    9590
                    let shift := sub(256, shl(3, length))
    9591
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9592
                }
    9593
                m0 := mload(0x00)
    9594
                m1 := mload(0x20)
    9595
                m2 := mload(0x40)
    9596
                m3 := mload(0x60)
    9597
                m4 := mload(0x80)
    9598
                m5 := mload(0xa0)
    9599
                m6 := mload(0xc0)
    9600
                // Selector of `log(uint256,uint256,bool,string)`.
    9601
                mstore(0x00, 0xa5b4fc99)
    9602
                mstore(0x20, p0)
    9603
                mstore(0x40, p1)
    9604
                mstore(0x60, p2)
    9605
                mstore(0x80, 0x80)
    9606
                writeString(0xa0, p3)
    9607
            }
    9608
            _sendLogPayload(0x1c, 0xc4);
    9609
            /// @solidity memory-safe-assembly
    9610
            assembly {
    9611
                mstore(0x00, m0)
    9612
                mstore(0x20, m1)
    9613
                mstore(0x40, m2)
    9614
                mstore(0x60, m3)
    9615
                mstore(0x80, m4)
    9616
                mstore(0xa0, m5)
    9617
                mstore(0xc0, m6)
    9618
            }
    9619
        }
    9620
    9621
        function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
    9622
            bytes32 m0;
    9623
            bytes32 m1;
    9624
            bytes32 m2;
    9625
            bytes32 m3;
    9626
            bytes32 m4;
    9627
            /// @solidity memory-safe-assembly
    9628
            assembly {
    9629
                m0 := mload(0x00)
    9630
                m1 := mload(0x20)
    9631
                m2 := mload(0x40)
    9632
                m3 := mload(0x60)
    9633
                m4 := mload(0x80)
    9634
                // Selector of `log(uint256,uint256,uint256,address)`.
    9635
                mstore(0x00, 0xfa8185af)
    9636
                mstore(0x20, p0)
    9637
                mstore(0x40, p1)
    9638
                mstore(0x60, p2)
    9639
                mstore(0x80, p3)
    9640
            }
    9641
            _sendLogPayload(0x1c, 0x84);
    9642
            /// @solidity memory-safe-assembly
    9643
            assembly {
    9644
                mstore(0x00, m0)
    9645
                mstore(0x20, m1)
    9646
                mstore(0x40, m2)
    9647
                mstore(0x60, m3)
    9648
                mstore(0x80, m4)
    9649
            }
    9650
        }
    9651
    9652
        function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    9653
            bytes32 m0;
    9654
            bytes32 m1;
    9655
            bytes32 m2;
    9656
            bytes32 m3;
    9657
            bytes32 m4;
    9658
            /// @solidity memory-safe-assembly
    9659
            assembly {
    9660
                m0 := mload(0x00)
    9661
                m1 := mload(0x20)
    9662
                m2 := mload(0x40)
    9663
                m3 := mload(0x60)
    9664
                m4 := mload(0x80)
    9665
                // Selector of `log(uint256,uint256,uint256,bool)`.
    9666
                mstore(0x00, 0xc598d185)
    9667
                mstore(0x20, p0)
    9668
                mstore(0x40, p1)
    9669
                mstore(0x60, p2)
    9670
                mstore(0x80, p3)
    9671
            }
    9672
            _sendLogPayload(0x1c, 0x84);
    9673
            /// @solidity memory-safe-assembly
    9674
            assembly {
    9675
                mstore(0x00, m0)
    9676
                mstore(0x20, m1)
    9677
                mstore(0x40, m2)
    9678
                mstore(0x60, m3)
    9679
                mstore(0x80, m4)
    9680
            }
    9681
        }
    9682
    9683
        function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    9684
            bytes32 m0;
    9685
            bytes32 m1;
    9686
            bytes32 m2;
    9687
            bytes32 m3;
    9688
            bytes32 m4;
    9689
            /// @solidity memory-safe-assembly
    9690
            assembly {
    9691
                m0 := mload(0x00)
    9692
                m1 := mload(0x20)
    9693
                m2 := mload(0x40)
    9694
                m3 := mload(0x60)
    9695
                m4 := mload(0x80)
    9696
                // Selector of `log(uint256,uint256,uint256,uint256)`.
    9697
                mstore(0x00, 0x193fb800)
    9698
                mstore(0x20, p0)
    9699
                mstore(0x40, p1)
    9700
                mstore(0x60, p2)
    9701
                mstore(0x80, p3)
    9702
            }
    9703
            _sendLogPayload(0x1c, 0x84);
    9704
            /// @solidity memory-safe-assembly
    9705
            assembly {
    9706
                mstore(0x00, m0)
    9707
                mstore(0x20, m1)
    9708
                mstore(0x40, m2)
    9709
                mstore(0x60, m3)
    9710
                mstore(0x80, m4)
    9711
            }
    9712
        }
    9713
    9714
        function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    9715
            bytes32 m0;
    9716
            bytes32 m1;
    9717
            bytes32 m2;
    9718
            bytes32 m3;
    9719
            bytes32 m4;
    9720
            bytes32 m5;
    9721
            bytes32 m6;
    9722
            /// @solidity memory-safe-assembly
    9723
            assembly {
    9724
                function writeString(pos, w) {
    9725
                    let length := 0
    9726
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9727
                    mstore(pos, length)
    9728
                    let shift := sub(256, shl(3, length))
    9729
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9730
                }
    9731
                m0 := mload(0x00)
    9732
                m1 := mload(0x20)
    9733
                m2 := mload(0x40)
    9734
                m3 := mload(0x60)
    9735
                m4 := mload(0x80)
    9736
                m5 := mload(0xa0)
    9737
                m6 := mload(0xc0)
    9738
                // Selector of `log(uint256,uint256,uint256,string)`.
    9739
                mstore(0x00, 0x59cfcbe3)
    9740
                mstore(0x20, p0)
    9741
                mstore(0x40, p1)
    9742
                mstore(0x60, p2)
    9743
                mstore(0x80, 0x80)
    9744
                writeString(0xa0, p3)
    9745
            }
    9746
            _sendLogPayload(0x1c, 0xc4);
    9747
            /// @solidity memory-safe-assembly
    9748
            assembly {
    9749
                mstore(0x00, m0)
    9750
                mstore(0x20, m1)
    9751
                mstore(0x40, m2)
    9752
                mstore(0x60, m3)
    9753
                mstore(0x80, m4)
    9754
                mstore(0xa0, m5)
    9755
                mstore(0xc0, m6)
    9756
            }
    9757
        }
    9758
    9759
        function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    9760
            bytes32 m0;
    9761
            bytes32 m1;
    9762
            bytes32 m2;
    9763
            bytes32 m3;
    9764
            bytes32 m4;
    9765
            bytes32 m5;
    9766
            bytes32 m6;
    9767
            /// @solidity memory-safe-assembly
    9768
            assembly {
    9769
                function writeString(pos, w) {
    9770
                    let length := 0
    9771
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9772
                    mstore(pos, length)
    9773
                    let shift := sub(256, shl(3, length))
    9774
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9775
                }
    9776
                m0 := mload(0x00)
    9777
                m1 := mload(0x20)
    9778
                m2 := mload(0x40)
    9779
                m3 := mload(0x60)
    9780
                m4 := mload(0x80)
    9781
                m5 := mload(0xa0)
    9782
                m6 := mload(0xc0)
    9783
                // Selector of `log(uint256,uint256,string,address)`.
    9784
                mstore(0x00, 0x42d21db7)
    9785
                mstore(0x20, p0)
    9786
                mstore(0x40, p1)
    9787
                mstore(0x60, 0x80)
    9788
                mstore(0x80, p3)
    9789
                writeString(0xa0, p2)
    9790
            }
    9791
            _sendLogPayload(0x1c, 0xc4);
    9792
            /// @solidity memory-safe-assembly
    9793
            assembly {
    9794
                mstore(0x00, m0)
    9795
                mstore(0x20, m1)
    9796
                mstore(0x40, m2)
    9797
                mstore(0x60, m3)
    9798
                mstore(0x80, m4)
    9799
                mstore(0xa0, m5)
    9800
                mstore(0xc0, m6)
    9801
            }
    9802
        }
    9803
    9804
        function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    9805
            bytes32 m0;
    9806
            bytes32 m1;
    9807
            bytes32 m2;
    9808
            bytes32 m3;
    9809
            bytes32 m4;
    9810
            bytes32 m5;
    9811
            bytes32 m6;
    9812
            /// @solidity memory-safe-assembly
    9813
            assembly {
    9814
                function writeString(pos, w) {
    9815
                    let length := 0
    9816
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9817
                    mstore(pos, length)
    9818
                    let shift := sub(256, shl(3, length))
    9819
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9820
                }
    9821
                m0 := mload(0x00)
    9822
                m1 := mload(0x20)
    9823
                m2 := mload(0x40)
    9824
                m3 := mload(0x60)
    9825
                m4 := mload(0x80)
    9826
                m5 := mload(0xa0)
    9827
                m6 := mload(0xc0)
    9828
                // Selector of `log(uint256,uint256,string,bool)`.
    9829
                mstore(0x00, 0x7af6ab25)
    9830
                mstore(0x20, p0)
    9831
                mstore(0x40, p1)
    9832
                mstore(0x60, 0x80)
    9833
                mstore(0x80, p3)
    9834
                writeString(0xa0, p2)
    9835
            }
    9836
            _sendLogPayload(0x1c, 0xc4);
    9837
            /// @solidity memory-safe-assembly
    9838
            assembly {
    9839
                mstore(0x00, m0)
    9840
                mstore(0x20, m1)
    9841
                mstore(0x40, m2)
    9842
                mstore(0x60, m3)
    9843
                mstore(0x80, m4)
    9844
                mstore(0xa0, m5)
    9845
                mstore(0xc0, m6)
    9846
            }
    9847
        }
    9848
    9849
        function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    9850
            bytes32 m0;
    9851
            bytes32 m1;
    9852
            bytes32 m2;
    9853
            bytes32 m3;
    9854
            bytes32 m4;
    9855
            bytes32 m5;
    9856
            bytes32 m6;
    9857
            /// @solidity memory-safe-assembly
    9858
            assembly {
    9859
                function writeString(pos, w) {
    9860
                    let length := 0
    9861
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9862
                    mstore(pos, length)
    9863
                    let shift := sub(256, shl(3, length))
    9864
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9865
                }
    9866
                m0 := mload(0x00)
    9867
                m1 := mload(0x20)
    9868
                m2 := mload(0x40)
    9869
                m3 := mload(0x60)
    9870
                m4 := mload(0x80)
    9871
                m5 := mload(0xa0)
    9872
                m6 := mload(0xc0)
    9873
                // Selector of `log(uint256,uint256,string,uint256)`.
    9874
                mstore(0x00, 0x5da297eb)
    9875
                mstore(0x20, p0)
    9876
                mstore(0x40, p1)
    9877
                mstore(0x60, 0x80)
    9878
                mstore(0x80, p3)
    9879
                writeString(0xa0, p2)
    9880
            }
    9881
            _sendLogPayload(0x1c, 0xc4);
    9882
            /// @solidity memory-safe-assembly
    9883
            assembly {
    9884
                mstore(0x00, m0)
    9885
                mstore(0x20, m1)
    9886
                mstore(0x40, m2)
    9887
                mstore(0x60, m3)
    9888
                mstore(0x80, m4)
    9889
                mstore(0xa0, m5)
    9890
                mstore(0xc0, m6)
    9891
            }
    9892
        }
    9893
    9894
        function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    9895
            bytes32 m0;
    9896
            bytes32 m1;
    9897
            bytes32 m2;
    9898
            bytes32 m3;
    9899
            bytes32 m4;
    9900
            bytes32 m5;
    9901
            bytes32 m6;
    9902
            bytes32 m7;
    9903
            bytes32 m8;
    9904
            /// @solidity memory-safe-assembly
    9905
            assembly {
    9906
                function writeString(pos, w) {
    9907
                    let length := 0
    9908
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9909
                    mstore(pos, length)
    9910
                    let shift := sub(256, shl(3, length))
    9911
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9912
                }
    9913
                m0 := mload(0x00)
    9914
                m1 := mload(0x20)
    9915
                m2 := mload(0x40)
    9916
                m3 := mload(0x60)
    9917
                m4 := mload(0x80)
    9918
                m5 := mload(0xa0)
    9919
                m6 := mload(0xc0)
    9920
                m7 := mload(0xe0)
    9921
                m8 := mload(0x100)
    9922
                // Selector of `log(uint256,uint256,string,string)`.
    9923
                mstore(0x00, 0x27d8afd2)
    9924
                mstore(0x20, p0)
    9925
                mstore(0x40, p1)
    9926
                mstore(0x60, 0x80)
    9927
                mstore(0x80, 0xc0)
    9928
                writeString(0xa0, p2)
    9929
                writeString(0xe0, p3)
    9930
            }
    9931
            _sendLogPayload(0x1c, 0x104);
    9932
            /// @solidity memory-safe-assembly
    9933
            assembly {
    9934
                mstore(0x00, m0)
    9935
                mstore(0x20, m1)
    9936
                mstore(0x40, m2)
    9937
                mstore(0x60, m3)
    9938
                mstore(0x80, m4)
    9939
                mstore(0xa0, m5)
    9940
                mstore(0xc0, m6)
    9941
                mstore(0xe0, m7)
    9942
                mstore(0x100, m8)
    9943
            }
    9944
        }
    9945
    9946
        function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {
    9947
            bytes32 m0;
    9948
            bytes32 m1;
    9949
            bytes32 m2;
    9950
            bytes32 m3;
    9951
            bytes32 m4;
    9952
            bytes32 m5;
    9953
            bytes32 m6;
    9954
            /// @solidity memory-safe-assembly
    9955
            assembly {
    9956
                function writeString(pos, w) {
    9957
                    let length := 0
    9958
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    9959
                    mstore(pos, length)
    9960
                    let shift := sub(256, shl(3, length))
    9961
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    9962
                }
    9963
                m0 := mload(0x00)
    9964
                m1 := mload(0x20)
    9965
                m2 := mload(0x40)
    9966
                m3 := mload(0x60)
    9967
                m4 := mload(0x80)
    9968
                m5 := mload(0xa0)
    9969
                m6 := mload(0xc0)
    9970
                // Selector of `log(uint256,string,address,address)`.
    9971
                mstore(0x00, 0x6168ed61)
    9972
                mstore(0x20, p0)
    9973
                mstore(0x40, 0x80)
    9974
                mstore(0x60, p2)
    9975
                mstore(0x80, p3)
    9976
                writeString(0xa0, p1)
    9977
            }
    9978
            _sendLogPayload(0x1c, 0xc4);
    9979
            /// @solidity memory-safe-assembly
    9980
            assembly {
    9981
                mstore(0x00, m0)
    9982
                mstore(0x20, m1)
    9983
                mstore(0x40, m2)
    9984
                mstore(0x60, m3)
    9985
                mstore(0x80, m4)
    9986
                mstore(0xa0, m5)
    9987
                mstore(0xc0, m6)
    9988
            }
    9989
        }
    9990
    9991
        function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {
    9992
            bytes32 m0;
    9993
            bytes32 m1;
    9994
            bytes32 m2;
    9995
            bytes32 m3;
    9996
            bytes32 m4;
    9997
            bytes32 m5;
    9998
            bytes32 m6;
    9999
            /// @solidity memory-safe-assembly
    10000
            assembly {
    10001
                function writeString(pos, w) {
    10002
                    let length := 0
    10003
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10004
                    mstore(pos, length)
    10005
                    let shift := sub(256, shl(3, length))
    10006
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10007
                }
    10008
                m0 := mload(0x00)
    10009
                m1 := mload(0x20)
    10010
                m2 := mload(0x40)
    10011
                m3 := mload(0x60)
    10012
                m4 := mload(0x80)
    10013
                m5 := mload(0xa0)
    10014
                m6 := mload(0xc0)
    10015
                // Selector of `log(uint256,string,address,bool)`.
    10016
                mstore(0x00, 0x90c30a56)
    10017
                mstore(0x20, p0)
    10018
                mstore(0x40, 0x80)
    10019
                mstore(0x60, p2)
    10020
                mstore(0x80, p3)
    10021
                writeString(0xa0, p1)
    10022
            }
    10023
            _sendLogPayload(0x1c, 0xc4);
    10024
            /// @solidity memory-safe-assembly
    10025
            assembly {
    10026
                mstore(0x00, m0)
    10027
                mstore(0x20, m1)
    10028
                mstore(0x40, m2)
    10029
                mstore(0x60, m3)
    10030
                mstore(0x80, m4)
    10031
                mstore(0xa0, m5)
    10032
                mstore(0xc0, m6)
    10033
            }
    10034
        }
    10035
    10036
        function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    10037
            bytes32 m0;
    10038
            bytes32 m1;
    10039
            bytes32 m2;
    10040
            bytes32 m3;
    10041
            bytes32 m4;
    10042
            bytes32 m5;
    10043
            bytes32 m6;
    10044
            /// @solidity memory-safe-assembly
    10045
            assembly {
    10046
                function writeString(pos, w) {
    10047
                    let length := 0
    10048
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10049
                    mstore(pos, length)
    10050
                    let shift := sub(256, shl(3, length))
    10051
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10052
                }
    10053
                m0 := mload(0x00)
    10054
                m1 := mload(0x20)
    10055
                m2 := mload(0x40)
    10056
                m3 := mload(0x60)
    10057
                m4 := mload(0x80)
    10058
                m5 := mload(0xa0)
    10059
                m6 := mload(0xc0)
    10060
                // Selector of `log(uint256,string,address,uint256)`.
    10061
                mstore(0x00, 0xe8d3018d)
    10062
                mstore(0x20, p0)
    10063
                mstore(0x40, 0x80)
    10064
                mstore(0x60, p2)
    10065
                mstore(0x80, p3)
    10066
                writeString(0xa0, p1)
    10067
            }
    10068
            _sendLogPayload(0x1c, 0xc4);
    10069
            /// @solidity memory-safe-assembly
    10070
            assembly {
    10071
                mstore(0x00, m0)
    10072
                mstore(0x20, m1)
    10073
                mstore(0x40, m2)
    10074
                mstore(0x60, m3)
    10075
                mstore(0x80, m4)
    10076
                mstore(0xa0, m5)
    10077
                mstore(0xc0, m6)
    10078
            }
    10079
        }
    10080
    10081
        function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    10082
            bytes32 m0;
    10083
            bytes32 m1;
    10084
            bytes32 m2;
    10085
            bytes32 m3;
    10086
            bytes32 m4;
    10087
            bytes32 m5;
    10088
            bytes32 m6;
    10089
            bytes32 m7;
    10090
            bytes32 m8;
    10091
            /// @solidity memory-safe-assembly
    10092
            assembly {
    10093
                function writeString(pos, w) {
    10094
                    let length := 0
    10095
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10096
                    mstore(pos, length)
    10097
                    let shift := sub(256, shl(3, length))
    10098
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10099
                }
    10100
                m0 := mload(0x00)
    10101
                m1 := mload(0x20)
    10102
                m2 := mload(0x40)
    10103
                m3 := mload(0x60)
    10104
                m4 := mload(0x80)
    10105
                m5 := mload(0xa0)
    10106
                m6 := mload(0xc0)
    10107
                m7 := mload(0xe0)
    10108
                m8 := mload(0x100)
    10109
                // Selector of `log(uint256,string,address,string)`.
    10110
                mstore(0x00, 0x9c3adfa1)
    10111
                mstore(0x20, p0)
    10112
                mstore(0x40, 0x80)
    10113
                mstore(0x60, p2)
    10114
                mstore(0x80, 0xc0)
    10115
                writeString(0xa0, p1)
    10116
                writeString(0xe0, p3)
    10117
            }
    10118
            _sendLogPayload(0x1c, 0x104);
    10119
            /// @solidity memory-safe-assembly
    10120
            assembly {
    10121
                mstore(0x00, m0)
    10122
                mstore(0x20, m1)
    10123
                mstore(0x40, m2)
    10124
                mstore(0x60, m3)
    10125
                mstore(0x80, m4)
    10126
                mstore(0xa0, m5)
    10127
                mstore(0xc0, m6)
    10128
                mstore(0xe0, m7)
    10129
                mstore(0x100, m8)
    10130
            }
    10131
        }
    10132
    10133
        function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {
    10134
            bytes32 m0;
    10135
            bytes32 m1;
    10136
            bytes32 m2;
    10137
            bytes32 m3;
    10138
            bytes32 m4;
    10139
            bytes32 m5;
    10140
            bytes32 m6;
    10141
            /// @solidity memory-safe-assembly
    10142
            assembly {
    10143
                function writeString(pos, w) {
    10144
                    let length := 0
    10145
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10146
                    mstore(pos, length)
    10147
                    let shift := sub(256, shl(3, length))
    10148
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10149
                }
    10150
                m0 := mload(0x00)
    10151
                m1 := mload(0x20)
    10152
                m2 := mload(0x40)
    10153
                m3 := mload(0x60)
    10154
                m4 := mload(0x80)
    10155
                m5 := mload(0xa0)
    10156
                m6 := mload(0xc0)
    10157
                // Selector of `log(uint256,string,bool,address)`.
    10158
                mstore(0x00, 0xae2ec581)
    10159
                mstore(0x20, p0)
    10160
                mstore(0x40, 0x80)
    10161
                mstore(0x60, p2)
    10162
                mstore(0x80, p3)
    10163
                writeString(0xa0, p1)
    10164
            }
    10165
            _sendLogPayload(0x1c, 0xc4);
    10166
            /// @solidity memory-safe-assembly
    10167
            assembly {
    10168
                mstore(0x00, m0)
    10169
                mstore(0x20, m1)
    10170
                mstore(0x40, m2)
    10171
                mstore(0x60, m3)
    10172
                mstore(0x80, m4)
    10173
                mstore(0xa0, m5)
    10174
                mstore(0xc0, m6)
    10175
            }
    10176
        }
    10177
    10178
        function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {
    10179
            bytes32 m0;
    10180
            bytes32 m1;
    10181
            bytes32 m2;
    10182
            bytes32 m3;
    10183
            bytes32 m4;
    10184
            bytes32 m5;
    10185
            bytes32 m6;
    10186
            /// @solidity memory-safe-assembly
    10187
            assembly {
    10188
                function writeString(pos, w) {
    10189
                    let length := 0
    10190
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10191
                    mstore(pos, length)
    10192
                    let shift := sub(256, shl(3, length))
    10193
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10194
                }
    10195
                m0 := mload(0x00)
    10196
                m1 := mload(0x20)
    10197
                m2 := mload(0x40)
    10198
                m3 := mload(0x60)
    10199
                m4 := mload(0x80)
    10200
                m5 := mload(0xa0)
    10201
                m6 := mload(0xc0)
    10202
                // Selector of `log(uint256,string,bool,bool)`.
    10203
                mstore(0x00, 0xba535d9c)
    10204
                mstore(0x20, p0)
    10205
                mstore(0x40, 0x80)
    10206
                mstore(0x60, p2)
    10207
                mstore(0x80, p3)
    10208
                writeString(0xa0, p1)
    10209
            }
    10210
            _sendLogPayload(0x1c, 0xc4);
    10211
            /// @solidity memory-safe-assembly
    10212
            assembly {
    10213
                mstore(0x00, m0)
    10214
                mstore(0x20, m1)
    10215
                mstore(0x40, m2)
    10216
                mstore(0x60, m3)
    10217
                mstore(0x80, m4)
    10218
                mstore(0xa0, m5)
    10219
                mstore(0xc0, m6)
    10220
            }
    10221
        }
    10222
    10223
        function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    10224
            bytes32 m0;
    10225
            bytes32 m1;
    10226
            bytes32 m2;
    10227
            bytes32 m3;
    10228
            bytes32 m4;
    10229
            bytes32 m5;
    10230
            bytes32 m6;
    10231
            /// @solidity memory-safe-assembly
    10232
            assembly {
    10233
                function writeString(pos, w) {
    10234
                    let length := 0
    10235
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10236
                    mstore(pos, length)
    10237
                    let shift := sub(256, shl(3, length))
    10238
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10239
                }
    10240
                m0 := mload(0x00)
    10241
                m1 := mload(0x20)
    10242
                m2 := mload(0x40)
    10243
                m3 := mload(0x60)
    10244
                m4 := mload(0x80)
    10245
                m5 := mload(0xa0)
    10246
                m6 := mload(0xc0)
    10247
                // Selector of `log(uint256,string,bool,uint256)`.
    10248
                mstore(0x00, 0xcf009880)
    10249
                mstore(0x20, p0)
    10250
                mstore(0x40, 0x80)
    10251
                mstore(0x60, p2)
    10252
                mstore(0x80, p3)
    10253
                writeString(0xa0, p1)
    10254
            }
    10255
            _sendLogPayload(0x1c, 0xc4);
    10256
            /// @solidity memory-safe-assembly
    10257
            assembly {
    10258
                mstore(0x00, m0)
    10259
                mstore(0x20, m1)
    10260
                mstore(0x40, m2)
    10261
                mstore(0x60, m3)
    10262
                mstore(0x80, m4)
    10263
                mstore(0xa0, m5)
    10264
                mstore(0xc0, m6)
    10265
            }
    10266
        }
    10267
    10268
        function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    10269
            bytes32 m0;
    10270
            bytes32 m1;
    10271
            bytes32 m2;
    10272
            bytes32 m3;
    10273
            bytes32 m4;
    10274
            bytes32 m5;
    10275
            bytes32 m6;
    10276
            bytes32 m7;
    10277
            bytes32 m8;
    10278
            /// @solidity memory-safe-assembly
    10279
            assembly {
    10280
                function writeString(pos, w) {
    10281
                    let length := 0
    10282
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10283
                    mstore(pos, length)
    10284
                    let shift := sub(256, shl(3, length))
    10285
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10286
                }
    10287
                m0 := mload(0x00)
    10288
                m1 := mload(0x20)
    10289
                m2 := mload(0x40)
    10290
                m3 := mload(0x60)
    10291
                m4 := mload(0x80)
    10292
                m5 := mload(0xa0)
    10293
                m6 := mload(0xc0)
    10294
                m7 := mload(0xe0)
    10295
                m8 := mload(0x100)
    10296
                // Selector of `log(uint256,string,bool,string)`.
    10297
                mstore(0x00, 0xd2d423cd)
    10298
                mstore(0x20, p0)
    10299
                mstore(0x40, 0x80)
    10300
                mstore(0x60, p2)
    10301
                mstore(0x80, 0xc0)
    10302
                writeString(0xa0, p1)
    10303
                writeString(0xe0, p3)
    10304
            }
    10305
            _sendLogPayload(0x1c, 0x104);
    10306
            /// @solidity memory-safe-assembly
    10307
            assembly {
    10308
                mstore(0x00, m0)
    10309
                mstore(0x20, m1)
    10310
                mstore(0x40, m2)
    10311
                mstore(0x60, m3)
    10312
                mstore(0x80, m4)
    10313
                mstore(0xa0, m5)
    10314
                mstore(0xc0, m6)
    10315
                mstore(0xe0, m7)
    10316
                mstore(0x100, m8)
    10317
            }
    10318
        }
    10319
    10320
        function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    10321
            bytes32 m0;
    10322
            bytes32 m1;
    10323
            bytes32 m2;
    10324
            bytes32 m3;
    10325
            bytes32 m4;
    10326
            bytes32 m5;
    10327
            bytes32 m6;
    10328
            /// @solidity memory-safe-assembly
    10329
            assembly {
    10330
                function writeString(pos, w) {
    10331
                    let length := 0
    10332
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10333
                    mstore(pos, length)
    10334
                    let shift := sub(256, shl(3, length))
    10335
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10336
                }
    10337
                m0 := mload(0x00)
    10338
                m1 := mload(0x20)
    10339
                m2 := mload(0x40)
    10340
                m3 := mload(0x60)
    10341
                m4 := mload(0x80)
    10342
                m5 := mload(0xa0)
    10343
                m6 := mload(0xc0)
    10344
                // Selector of `log(uint256,string,uint256,address)`.
    10345
                mstore(0x00, 0x3b2279b4)
    10346
                mstore(0x20, p0)
    10347
                mstore(0x40, 0x80)
    10348
                mstore(0x60, p2)
    10349
                mstore(0x80, p3)
    10350
                writeString(0xa0, p1)
    10351
            }
    10352
            _sendLogPayload(0x1c, 0xc4);
    10353
            /// @solidity memory-safe-assembly
    10354
            assembly {
    10355
                mstore(0x00, m0)
    10356
                mstore(0x20, m1)
    10357
                mstore(0x40, m2)
    10358
                mstore(0x60, m3)
    10359
                mstore(0x80, m4)
    10360
                mstore(0xa0, m5)
    10361
                mstore(0xc0, m6)
    10362
            }
    10363
        }
    10364
    10365
        function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    10366
            bytes32 m0;
    10367
            bytes32 m1;
    10368
            bytes32 m2;
    10369
            bytes32 m3;
    10370
            bytes32 m4;
    10371
            bytes32 m5;
    10372
            bytes32 m6;
    10373
            /// @solidity memory-safe-assembly
    10374
            assembly {
    10375
                function writeString(pos, w) {
    10376
                    let length := 0
    10377
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10378
                    mstore(pos, length)
    10379
                    let shift := sub(256, shl(3, length))
    10380
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10381
                }
    10382
                m0 := mload(0x00)
    10383
                m1 := mload(0x20)
    10384
                m2 := mload(0x40)
    10385
                m3 := mload(0x60)
    10386
                m4 := mload(0x80)
    10387
                m5 := mload(0xa0)
    10388
                m6 := mload(0xc0)
    10389
                // Selector of `log(uint256,string,uint256,bool)`.
    10390
                mstore(0x00, 0x691a8f74)
    10391
                mstore(0x20, p0)
    10392
                mstore(0x40, 0x80)
    10393
                mstore(0x60, p2)
    10394
                mstore(0x80, p3)
    10395
                writeString(0xa0, p1)
    10396
            }
    10397
            _sendLogPayload(0x1c, 0xc4);
    10398
            /// @solidity memory-safe-assembly
    10399
            assembly {
    10400
                mstore(0x00, m0)
    10401
                mstore(0x20, m1)
    10402
                mstore(0x40, m2)
    10403
                mstore(0x60, m3)
    10404
                mstore(0x80, m4)
    10405
                mstore(0xa0, m5)
    10406
                mstore(0xc0, m6)
    10407
            }
    10408
        }
    10409
    10410
        function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    10411
            bytes32 m0;
    10412
            bytes32 m1;
    10413
            bytes32 m2;
    10414
            bytes32 m3;
    10415
            bytes32 m4;
    10416
            bytes32 m5;
    10417
            bytes32 m6;
    10418
            /// @solidity memory-safe-assembly
    10419
            assembly {
    10420
                function writeString(pos, w) {
    10421
                    let length := 0
    10422
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10423
                    mstore(pos, length)
    10424
                    let shift := sub(256, shl(3, length))
    10425
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10426
                }
    10427
                m0 := mload(0x00)
    10428
                m1 := mload(0x20)
    10429
                m2 := mload(0x40)
    10430
                m3 := mload(0x60)
    10431
                m4 := mload(0x80)
    10432
                m5 := mload(0xa0)
    10433
                m6 := mload(0xc0)
    10434
                // Selector of `log(uint256,string,uint256,uint256)`.
    10435
                mstore(0x00, 0x82c25b74)
    10436
                mstore(0x20, p0)
    10437
                mstore(0x40, 0x80)
    10438
                mstore(0x60, p2)
    10439
                mstore(0x80, p3)
    10440
                writeString(0xa0, p1)
    10441
            }
    10442
            _sendLogPayload(0x1c, 0xc4);
    10443
            /// @solidity memory-safe-assembly
    10444
            assembly {
    10445
                mstore(0x00, m0)
    10446
                mstore(0x20, m1)
    10447
                mstore(0x40, m2)
    10448
                mstore(0x60, m3)
    10449
                mstore(0x80, m4)
    10450
                mstore(0xa0, m5)
    10451
                mstore(0xc0, m6)
    10452
            }
    10453
        }
    10454
    10455
        function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    10456
            bytes32 m0;
    10457
            bytes32 m1;
    10458
            bytes32 m2;
    10459
            bytes32 m3;
    10460
            bytes32 m4;
    10461
            bytes32 m5;
    10462
            bytes32 m6;
    10463
            bytes32 m7;
    10464
            bytes32 m8;
    10465
            /// @solidity memory-safe-assembly
    10466
            assembly {
    10467
                function writeString(pos, w) {
    10468
                    let length := 0
    10469
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10470
                    mstore(pos, length)
    10471
                    let shift := sub(256, shl(3, length))
    10472
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10473
                }
    10474
                m0 := mload(0x00)
    10475
                m1 := mload(0x20)
    10476
                m2 := mload(0x40)
    10477
                m3 := mload(0x60)
    10478
                m4 := mload(0x80)
    10479
                m5 := mload(0xa0)
    10480
                m6 := mload(0xc0)
    10481
                m7 := mload(0xe0)
    10482
                m8 := mload(0x100)
    10483
                // Selector of `log(uint256,string,uint256,string)`.
    10484
                mstore(0x00, 0xb7b914ca)
    10485
                mstore(0x20, p0)
    10486
                mstore(0x40, 0x80)
    10487
                mstore(0x60, p2)
    10488
                mstore(0x80, 0xc0)
    10489
                writeString(0xa0, p1)
    10490
                writeString(0xe0, p3)
    10491
            }
    10492
            _sendLogPayload(0x1c, 0x104);
    10493
            /// @solidity memory-safe-assembly
    10494
            assembly {
    10495
                mstore(0x00, m0)
    10496
                mstore(0x20, m1)
    10497
                mstore(0x40, m2)
    10498
                mstore(0x60, m3)
    10499
                mstore(0x80, m4)
    10500
                mstore(0xa0, m5)
    10501
                mstore(0xc0, m6)
    10502
                mstore(0xe0, m7)
    10503
                mstore(0x100, m8)
    10504
            }
    10505
        }
    10506
    10507
        function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    10508
            bytes32 m0;
    10509
            bytes32 m1;
    10510
            bytes32 m2;
    10511
            bytes32 m3;
    10512
            bytes32 m4;
    10513
            bytes32 m5;
    10514
            bytes32 m6;
    10515
            bytes32 m7;
    10516
            bytes32 m8;
    10517
            /// @solidity memory-safe-assembly
    10518
            assembly {
    10519
                function writeString(pos, w) {
    10520
                    let length := 0
    10521
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10522
                    mstore(pos, length)
    10523
                    let shift := sub(256, shl(3, length))
    10524
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10525
                }
    10526
                m0 := mload(0x00)
    10527
                m1 := mload(0x20)
    10528
                m2 := mload(0x40)
    10529
                m3 := mload(0x60)
    10530
                m4 := mload(0x80)
    10531
                m5 := mload(0xa0)
    10532
                m6 := mload(0xc0)
    10533
                m7 := mload(0xe0)
    10534
                m8 := mload(0x100)
    10535
                // Selector of `log(uint256,string,string,address)`.
    10536
                mstore(0x00, 0xd583c602)
    10537
                mstore(0x20, p0)
    10538
                mstore(0x40, 0x80)
    10539
                mstore(0x60, 0xc0)
    10540
                mstore(0x80, p3)
    10541
                writeString(0xa0, p1)
    10542
                writeString(0xe0, p2)
    10543
            }
    10544
            _sendLogPayload(0x1c, 0x104);
    10545
            /// @solidity memory-safe-assembly
    10546
            assembly {
    10547
                mstore(0x00, m0)
    10548
                mstore(0x20, m1)
    10549
                mstore(0x40, m2)
    10550
                mstore(0x60, m3)
    10551
                mstore(0x80, m4)
    10552
                mstore(0xa0, m5)
    10553
                mstore(0xc0, m6)
    10554
                mstore(0xe0, m7)
    10555
                mstore(0x100, m8)
    10556
            }
    10557
        }
    10558
    10559
        function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    10560
            bytes32 m0;
    10561
            bytes32 m1;
    10562
            bytes32 m2;
    10563
            bytes32 m3;
    10564
            bytes32 m4;
    10565
            bytes32 m5;
    10566
            bytes32 m6;
    10567
            bytes32 m7;
    10568
            bytes32 m8;
    10569
            /// @solidity memory-safe-assembly
    10570
            assembly {
    10571
                function writeString(pos, w) {
    10572
                    let length := 0
    10573
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10574
                    mstore(pos, length)
    10575
                    let shift := sub(256, shl(3, length))
    10576
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10577
                }
    10578
                m0 := mload(0x00)
    10579
                m1 := mload(0x20)
    10580
                m2 := mload(0x40)
    10581
                m3 := mload(0x60)
    10582
                m4 := mload(0x80)
    10583
                m5 := mload(0xa0)
    10584
                m6 := mload(0xc0)
    10585
                m7 := mload(0xe0)
    10586
                m8 := mload(0x100)
    10587
                // Selector of `log(uint256,string,string,bool)`.
    10588
                mstore(0x00, 0xb3a6b6bd)
    10589
                mstore(0x20, p0)
    10590
                mstore(0x40, 0x80)
    10591
                mstore(0x60, 0xc0)
    10592
                mstore(0x80, p3)
    10593
                writeString(0xa0, p1)
    10594
                writeString(0xe0, p2)
    10595
            }
    10596
            _sendLogPayload(0x1c, 0x104);
    10597
            /// @solidity memory-safe-assembly
    10598
            assembly {
    10599
                mstore(0x00, m0)
    10600
                mstore(0x20, m1)
    10601
                mstore(0x40, m2)
    10602
                mstore(0x60, m3)
    10603
                mstore(0x80, m4)
    10604
                mstore(0xa0, m5)
    10605
                mstore(0xc0, m6)
    10606
                mstore(0xe0, m7)
    10607
                mstore(0x100, m8)
    10608
            }
    10609
        }
    10610
    10611
        function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    10612
            bytes32 m0;
    10613
            bytes32 m1;
    10614
            bytes32 m2;
    10615
            bytes32 m3;
    10616
            bytes32 m4;
    10617
            bytes32 m5;
    10618
            bytes32 m6;
    10619
            bytes32 m7;
    10620
            bytes32 m8;
    10621
            /// @solidity memory-safe-assembly
    10622
            assembly {
    10623
                function writeString(pos, w) {
    10624
                    let length := 0
    10625
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10626
                    mstore(pos, length)
    10627
                    let shift := sub(256, shl(3, length))
    10628
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10629
                }
    10630
                m0 := mload(0x00)
    10631
                m1 := mload(0x20)
    10632
                m2 := mload(0x40)
    10633
                m3 := mload(0x60)
    10634
                m4 := mload(0x80)
    10635
                m5 := mload(0xa0)
    10636
                m6 := mload(0xc0)
    10637
                m7 := mload(0xe0)
    10638
                m8 := mload(0x100)
    10639
                // Selector of `log(uint256,string,string,uint256)`.
    10640
                mstore(0x00, 0xb028c9bd)
    10641
                mstore(0x20, p0)
    10642
                mstore(0x40, 0x80)
    10643
                mstore(0x60, 0xc0)
    10644
                mstore(0x80, p3)
    10645
                writeString(0xa0, p1)
    10646
                writeString(0xe0, p2)
    10647
            }
    10648
            _sendLogPayload(0x1c, 0x104);
    10649
            /// @solidity memory-safe-assembly
    10650
            assembly {
    10651
                mstore(0x00, m0)
    10652
                mstore(0x20, m1)
    10653
                mstore(0x40, m2)
    10654
                mstore(0x60, m3)
    10655
                mstore(0x80, m4)
    10656
                mstore(0xa0, m5)
    10657
                mstore(0xc0, m6)
    10658
                mstore(0xe0, m7)
    10659
                mstore(0x100, m8)
    10660
            }
    10661
        }
    10662
    10663
        function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    10664
            bytes32 m0;
    10665
            bytes32 m1;
    10666
            bytes32 m2;
    10667
            bytes32 m3;
    10668
            bytes32 m4;
    10669
            bytes32 m5;
    10670
            bytes32 m6;
    10671
            bytes32 m7;
    10672
            bytes32 m8;
    10673
            bytes32 m9;
    10674
            bytes32 m10;
    10675
            /// @solidity memory-safe-assembly
    10676
            assembly {
    10677
                function writeString(pos, w) {
    10678
                    let length := 0
    10679
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10680
                    mstore(pos, length)
    10681
                    let shift := sub(256, shl(3, length))
    10682
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10683
                }
    10684
                m0 := mload(0x00)
    10685
                m1 := mload(0x20)
    10686
                m2 := mload(0x40)
    10687
                m3 := mload(0x60)
    10688
                m4 := mload(0x80)
    10689
                m5 := mload(0xa0)
    10690
                m6 := mload(0xc0)
    10691
                m7 := mload(0xe0)
    10692
                m8 := mload(0x100)
    10693
                m9 := mload(0x120)
    10694
                m10 := mload(0x140)
    10695
                // Selector of `log(uint256,string,string,string)`.
    10696
                mstore(0x00, 0x21ad0683)
    10697
                mstore(0x20, p0)
    10698
                mstore(0x40, 0x80)
    10699
                mstore(0x60, 0xc0)
    10700
                mstore(0x80, 0x100)
    10701
                writeString(0xa0, p1)
    10702
                writeString(0xe0, p2)
    10703
                writeString(0x120, p3)
    10704
            }
    10705
            _sendLogPayload(0x1c, 0x144);
    10706
            /// @solidity memory-safe-assembly
    10707
            assembly {
    10708
                mstore(0x00, m0)
    10709
                mstore(0x20, m1)
    10710
                mstore(0x40, m2)
    10711
                mstore(0x60, m3)
    10712
                mstore(0x80, m4)
    10713
                mstore(0xa0, m5)
    10714
                mstore(0xc0, m6)
    10715
                mstore(0xe0, m7)
    10716
                mstore(0x100, m8)
    10717
                mstore(0x120, m9)
    10718
                mstore(0x140, m10)
    10719
            }
    10720
        }
    10721
    10722
        function log(bytes32 p0, address p1, address p2, address p3) internal pure {
    10723
            bytes32 m0;
    10724
            bytes32 m1;
    10725
            bytes32 m2;
    10726
            bytes32 m3;
    10727
            bytes32 m4;
    10728
            bytes32 m5;
    10729
            bytes32 m6;
    10730
            /// @solidity memory-safe-assembly
    10731
            assembly {
    10732
                function writeString(pos, w) {
    10733
                    let length := 0
    10734
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10735
                    mstore(pos, length)
    10736
                    let shift := sub(256, shl(3, length))
    10737
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10738
                }
    10739
                m0 := mload(0x00)
    10740
                m1 := mload(0x20)
    10741
                m2 := mload(0x40)
    10742
                m3 := mload(0x60)
    10743
                m4 := mload(0x80)
    10744
                m5 := mload(0xa0)
    10745
                m6 := mload(0xc0)
    10746
                // Selector of `log(string,address,address,address)`.
    10747
                mstore(0x00, 0xed8f28f6)
    10748
                mstore(0x20, 0x80)
    10749
                mstore(0x40, p1)
    10750
                mstore(0x60, p2)
    10751
                mstore(0x80, p3)
    10752
                writeString(0xa0, p0)
    10753
            }
    10754
            _sendLogPayload(0x1c, 0xc4);
    10755
            /// @solidity memory-safe-assembly
    10756
            assembly {
    10757
                mstore(0x00, m0)
    10758
                mstore(0x20, m1)
    10759
                mstore(0x40, m2)
    10760
                mstore(0x60, m3)
    10761
                mstore(0x80, m4)
    10762
                mstore(0xa0, m5)
    10763
                mstore(0xc0, m6)
    10764
            }
    10765
        }
    10766
    10767
        function log(bytes32 p0, address p1, address p2, bool p3) internal pure {
    10768
            bytes32 m0;
    10769
            bytes32 m1;
    10770
            bytes32 m2;
    10771
            bytes32 m3;
    10772
            bytes32 m4;
    10773
            bytes32 m5;
    10774
            bytes32 m6;
    10775
            /// @solidity memory-safe-assembly
    10776
            assembly {
    10777
                function writeString(pos, w) {
    10778
                    let length := 0
    10779
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10780
                    mstore(pos, length)
    10781
                    let shift := sub(256, shl(3, length))
    10782
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10783
                }
    10784
                m0 := mload(0x00)
    10785
                m1 := mload(0x20)
    10786
                m2 := mload(0x40)
    10787
                m3 := mload(0x60)
    10788
                m4 := mload(0x80)
    10789
                m5 := mload(0xa0)
    10790
                m6 := mload(0xc0)
    10791
                // Selector of `log(string,address,address,bool)`.
    10792
                mstore(0x00, 0xb59dbd60)
    10793
                mstore(0x20, 0x80)
    10794
                mstore(0x40, p1)
    10795
                mstore(0x60, p2)
    10796
                mstore(0x80, p3)
    10797
                writeString(0xa0, p0)
    10798
            }
    10799
            _sendLogPayload(0x1c, 0xc4);
    10800
            /// @solidity memory-safe-assembly
    10801
            assembly {
    10802
                mstore(0x00, m0)
    10803
                mstore(0x20, m1)
    10804
                mstore(0x40, m2)
    10805
                mstore(0x60, m3)
    10806
                mstore(0x80, m4)
    10807
                mstore(0xa0, m5)
    10808
                mstore(0xc0, m6)
    10809
            }
    10810
        }
    10811
    10812
        function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {
    10813
            bytes32 m0;
    10814
            bytes32 m1;
    10815
            bytes32 m2;
    10816
            bytes32 m3;
    10817
            bytes32 m4;
    10818
            bytes32 m5;
    10819
            bytes32 m6;
    10820
            /// @solidity memory-safe-assembly
    10821
            assembly {
    10822
                function writeString(pos, w) {
    10823
                    let length := 0
    10824
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10825
                    mstore(pos, length)
    10826
                    let shift := sub(256, shl(3, length))
    10827
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10828
                }
    10829
                m0 := mload(0x00)
    10830
                m1 := mload(0x20)
    10831
                m2 := mload(0x40)
    10832
                m3 := mload(0x60)
    10833
                m4 := mload(0x80)
    10834
                m5 := mload(0xa0)
    10835
                m6 := mload(0xc0)
    10836
                // Selector of `log(string,address,address,uint256)`.
    10837
                mstore(0x00, 0x8ef3f399)
    10838
                mstore(0x20, 0x80)
    10839
                mstore(0x40, p1)
    10840
                mstore(0x60, p2)
    10841
                mstore(0x80, p3)
    10842
                writeString(0xa0, p0)
    10843
            }
    10844
            _sendLogPayload(0x1c, 0xc4);
    10845
            /// @solidity memory-safe-assembly
    10846
            assembly {
    10847
                mstore(0x00, m0)
    10848
                mstore(0x20, m1)
    10849
                mstore(0x40, m2)
    10850
                mstore(0x60, m3)
    10851
                mstore(0x80, m4)
    10852
                mstore(0xa0, m5)
    10853
                mstore(0xc0, m6)
    10854
            }
    10855
        }
    10856
    10857
        function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {
    10858
            bytes32 m0;
    10859
            bytes32 m1;
    10860
            bytes32 m2;
    10861
            bytes32 m3;
    10862
            bytes32 m4;
    10863
            bytes32 m5;
    10864
            bytes32 m6;
    10865
            bytes32 m7;
    10866
            bytes32 m8;
    10867
            /// @solidity memory-safe-assembly
    10868
            assembly {
    10869
                function writeString(pos, w) {
    10870
                    let length := 0
    10871
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10872
                    mstore(pos, length)
    10873
                    let shift := sub(256, shl(3, length))
    10874
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10875
                }
    10876
                m0 := mload(0x00)
    10877
                m1 := mload(0x20)
    10878
                m2 := mload(0x40)
    10879
                m3 := mload(0x60)
    10880
                m4 := mload(0x80)
    10881
                m5 := mload(0xa0)
    10882
                m6 := mload(0xc0)
    10883
                m7 := mload(0xe0)
    10884
                m8 := mload(0x100)
    10885
                // Selector of `log(string,address,address,string)`.
    10886
                mstore(0x00, 0x800a1c67)
    10887
                mstore(0x20, 0x80)
    10888
                mstore(0x40, p1)
    10889
                mstore(0x60, p2)
    10890
                mstore(0x80, 0xc0)
    10891
                writeString(0xa0, p0)
    10892
                writeString(0xe0, p3)
    10893
            }
    10894
            _sendLogPayload(0x1c, 0x104);
    10895
            /// @solidity memory-safe-assembly
    10896
            assembly {
    10897
                mstore(0x00, m0)
    10898
                mstore(0x20, m1)
    10899
                mstore(0x40, m2)
    10900
                mstore(0x60, m3)
    10901
                mstore(0x80, m4)
    10902
                mstore(0xa0, m5)
    10903
                mstore(0xc0, m6)
    10904
                mstore(0xe0, m7)
    10905
                mstore(0x100, m8)
    10906
            }
    10907
        }
    10908
    10909
        function log(bytes32 p0, address p1, bool p2, address p3) internal pure {
    10910
            bytes32 m0;
    10911
            bytes32 m1;
    10912
            bytes32 m2;
    10913
            bytes32 m3;
    10914
            bytes32 m4;
    10915
            bytes32 m5;
    10916
            bytes32 m6;
    10917
            /// @solidity memory-safe-assembly
    10918
            assembly {
    10919
                function writeString(pos, w) {
    10920
                    let length := 0
    10921
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10922
                    mstore(pos, length)
    10923
                    let shift := sub(256, shl(3, length))
    10924
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10925
                }
    10926
                m0 := mload(0x00)
    10927
                m1 := mload(0x20)
    10928
                m2 := mload(0x40)
    10929
                m3 := mload(0x60)
    10930
                m4 := mload(0x80)
    10931
                m5 := mload(0xa0)
    10932
                m6 := mload(0xc0)
    10933
                // Selector of `log(string,address,bool,address)`.
    10934
                mstore(0x00, 0x223603bd)
    10935
                mstore(0x20, 0x80)
    10936
                mstore(0x40, p1)
    10937
                mstore(0x60, p2)
    10938
                mstore(0x80, p3)
    10939
                writeString(0xa0, p0)
    10940
            }
    10941
            _sendLogPayload(0x1c, 0xc4);
    10942
            /// @solidity memory-safe-assembly
    10943
            assembly {
    10944
                mstore(0x00, m0)
    10945
                mstore(0x20, m1)
    10946
                mstore(0x40, m2)
    10947
                mstore(0x60, m3)
    10948
                mstore(0x80, m4)
    10949
                mstore(0xa0, m5)
    10950
                mstore(0xc0, m6)
    10951
            }
    10952
        }
    10953
    10954
        function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {
    10955
            bytes32 m0;
    10956
            bytes32 m1;
    10957
            bytes32 m2;
    10958
            bytes32 m3;
    10959
            bytes32 m4;
    10960
            bytes32 m5;
    10961
            bytes32 m6;
    10962
            /// @solidity memory-safe-assembly
    10963
            assembly {
    10964
                function writeString(pos, w) {
    10965
                    let length := 0
    10966
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    10967
                    mstore(pos, length)
    10968
                    let shift := sub(256, shl(3, length))
    10969
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    10970
                }
    10971
                m0 := mload(0x00)
    10972
                m1 := mload(0x20)
    10973
                m2 := mload(0x40)
    10974
                m3 := mload(0x60)
    10975
                m4 := mload(0x80)
    10976
                m5 := mload(0xa0)
    10977
                m6 := mload(0xc0)
    10978
                // Selector of `log(string,address,bool,bool)`.
    10979
                mstore(0x00, 0x79884c2b)
    10980
                mstore(0x20, 0x80)
    10981
                mstore(0x40, p1)
    10982
                mstore(0x60, p2)
    10983
                mstore(0x80, p3)
    10984
                writeString(0xa0, p0)
    10985
            }
    10986
            _sendLogPayload(0x1c, 0xc4);
    10987
            /// @solidity memory-safe-assembly
    10988
            assembly {
    10989
                mstore(0x00, m0)
    10990
                mstore(0x20, m1)
    10991
                mstore(0x40, m2)
    10992
                mstore(0x60, m3)
    10993
                mstore(0x80, m4)
    10994
                mstore(0xa0, m5)
    10995
                mstore(0xc0, m6)
    10996
            }
    10997
        }
    10998
    10999
        function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {
    11000
            bytes32 m0;
    11001
            bytes32 m1;
    11002
            bytes32 m2;
    11003
            bytes32 m3;
    11004
            bytes32 m4;
    11005
            bytes32 m5;
    11006
            bytes32 m6;
    11007
            /// @solidity memory-safe-assembly
    11008
            assembly {
    11009
                function writeString(pos, w) {
    11010
                    let length := 0
    11011
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11012
                    mstore(pos, length)
    11013
                    let shift := sub(256, shl(3, length))
    11014
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11015
                }
    11016
                m0 := mload(0x00)
    11017
                m1 := mload(0x20)
    11018
                m2 := mload(0x40)
    11019
                m3 := mload(0x60)
    11020
                m4 := mload(0x80)
    11021
                m5 := mload(0xa0)
    11022
                m6 := mload(0xc0)
    11023
                // Selector of `log(string,address,bool,uint256)`.
    11024
                mstore(0x00, 0x3e9f866a)
    11025
                mstore(0x20, 0x80)
    11026
                mstore(0x40, p1)
    11027
                mstore(0x60, p2)
    11028
                mstore(0x80, p3)
    11029
                writeString(0xa0, p0)
    11030
            }
    11031
            _sendLogPayload(0x1c, 0xc4);
    11032
            /// @solidity memory-safe-assembly
    11033
            assembly {
    11034
                mstore(0x00, m0)
    11035
                mstore(0x20, m1)
    11036
                mstore(0x40, m2)
    11037
                mstore(0x60, m3)
    11038
                mstore(0x80, m4)
    11039
                mstore(0xa0, m5)
    11040
                mstore(0xc0, m6)
    11041
            }
    11042
        }
    11043
    11044
        function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {
    11045
            bytes32 m0;
    11046
            bytes32 m1;
    11047
            bytes32 m2;
    11048
            bytes32 m3;
    11049
            bytes32 m4;
    11050
            bytes32 m5;
    11051
            bytes32 m6;
    11052
            bytes32 m7;
    11053
            bytes32 m8;
    11054
            /// @solidity memory-safe-assembly
    11055
            assembly {
    11056
                function writeString(pos, w) {
    11057
                    let length := 0
    11058
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11059
                    mstore(pos, length)
    11060
                    let shift := sub(256, shl(3, length))
    11061
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11062
                }
    11063
                m0 := mload(0x00)
    11064
                m1 := mload(0x20)
    11065
                m2 := mload(0x40)
    11066
                m3 := mload(0x60)
    11067
                m4 := mload(0x80)
    11068
                m5 := mload(0xa0)
    11069
                m6 := mload(0xc0)
    11070
                m7 := mload(0xe0)
    11071
                m8 := mload(0x100)
    11072
                // Selector of `log(string,address,bool,string)`.
    11073
                mstore(0x00, 0x0454c079)
    11074
                mstore(0x20, 0x80)
    11075
                mstore(0x40, p1)
    11076
                mstore(0x60, p2)
    11077
                mstore(0x80, 0xc0)
    11078
                writeString(0xa0, p0)
    11079
                writeString(0xe0, p3)
    11080
            }
    11081
            _sendLogPayload(0x1c, 0x104);
    11082
            /// @solidity memory-safe-assembly
    11083
            assembly {
    11084
                mstore(0x00, m0)
    11085
                mstore(0x20, m1)
    11086
                mstore(0x40, m2)
    11087
                mstore(0x60, m3)
    11088
                mstore(0x80, m4)
    11089
                mstore(0xa0, m5)
    11090
                mstore(0xc0, m6)
    11091
                mstore(0xe0, m7)
    11092
                mstore(0x100, m8)
    11093
            }
    11094
        }
    11095
    11096
        function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {
    11097
            bytes32 m0;
    11098
            bytes32 m1;
    11099
            bytes32 m2;
    11100
            bytes32 m3;
    11101
            bytes32 m4;
    11102
            bytes32 m5;
    11103
            bytes32 m6;
    11104
            /// @solidity memory-safe-assembly
    11105
            assembly {
    11106
                function writeString(pos, w) {
    11107
                    let length := 0
    11108
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11109
                    mstore(pos, length)
    11110
                    let shift := sub(256, shl(3, length))
    11111
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11112
                }
    11113
                m0 := mload(0x00)
    11114
                m1 := mload(0x20)
    11115
                m2 := mload(0x40)
    11116
                m3 := mload(0x60)
    11117
                m4 := mload(0x80)
    11118
                m5 := mload(0xa0)
    11119
                m6 := mload(0xc0)
    11120
                // Selector of `log(string,address,uint256,address)`.
    11121
                mstore(0x00, 0x63fb8bc5)
    11122
                mstore(0x20, 0x80)
    11123
                mstore(0x40, p1)
    11124
                mstore(0x60, p2)
    11125
                mstore(0x80, p3)
    11126
                writeString(0xa0, p0)
    11127
            }
    11128
            _sendLogPayload(0x1c, 0xc4);
    11129
            /// @solidity memory-safe-assembly
    11130
            assembly {
    11131
                mstore(0x00, m0)
    11132
                mstore(0x20, m1)
    11133
                mstore(0x40, m2)
    11134
                mstore(0x60, m3)
    11135
                mstore(0x80, m4)
    11136
                mstore(0xa0, m5)
    11137
                mstore(0xc0, m6)
    11138
            }
    11139
        }
    11140
    11141
        function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {
    11142
            bytes32 m0;
    11143
            bytes32 m1;
    11144
            bytes32 m2;
    11145
            bytes32 m3;
    11146
            bytes32 m4;
    11147
            bytes32 m5;
    11148
            bytes32 m6;
    11149
            /// @solidity memory-safe-assembly
    11150
            assembly {
    11151
                function writeString(pos, w) {
    11152
                    let length := 0
    11153
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11154
                    mstore(pos, length)
    11155
                    let shift := sub(256, shl(3, length))
    11156
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11157
                }
    11158
                m0 := mload(0x00)
    11159
                m1 := mload(0x20)
    11160
                m2 := mload(0x40)
    11161
                m3 := mload(0x60)
    11162
                m4 := mload(0x80)
    11163
                m5 := mload(0xa0)
    11164
                m6 := mload(0xc0)
    11165
                // Selector of `log(string,address,uint256,bool)`.
    11166
                mstore(0x00, 0xfc4845f0)
    11167
                mstore(0x20, 0x80)
    11168
                mstore(0x40, p1)
    11169
                mstore(0x60, p2)
    11170
                mstore(0x80, p3)
    11171
                writeString(0xa0, p0)
    11172
            }
    11173
            _sendLogPayload(0x1c, 0xc4);
    11174
            /// @solidity memory-safe-assembly
    11175
            assembly {
    11176
                mstore(0x00, m0)
    11177
                mstore(0x20, m1)
    11178
                mstore(0x40, m2)
    11179
                mstore(0x60, m3)
    11180
                mstore(0x80, m4)
    11181
                mstore(0xa0, m5)
    11182
                mstore(0xc0, m6)
    11183
            }
    11184
        }
    11185
    11186
        function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {
    11187
            bytes32 m0;
    11188
            bytes32 m1;
    11189
            bytes32 m2;
    11190
            bytes32 m3;
    11191
            bytes32 m4;
    11192
            bytes32 m5;
    11193
            bytes32 m6;
    11194
            /// @solidity memory-safe-assembly
    11195
            assembly {
    11196
                function writeString(pos, w) {
    11197
                    let length := 0
    11198
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11199
                    mstore(pos, length)
    11200
                    let shift := sub(256, shl(3, length))
    11201
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11202
                }
    11203
                m0 := mload(0x00)
    11204
                m1 := mload(0x20)
    11205
                m2 := mload(0x40)
    11206
                m3 := mload(0x60)
    11207
                m4 := mload(0x80)
    11208
                m5 := mload(0xa0)
    11209
                m6 := mload(0xc0)
    11210
                // Selector of `log(string,address,uint256,uint256)`.
    11211
                mstore(0x00, 0xf8f51b1e)
    11212
                mstore(0x20, 0x80)
    11213
                mstore(0x40, p1)
    11214
                mstore(0x60, p2)
    11215
                mstore(0x80, p3)
    11216
                writeString(0xa0, p0)
    11217
            }
    11218
            _sendLogPayload(0x1c, 0xc4);
    11219
            /// @solidity memory-safe-assembly
    11220
            assembly {
    11221
                mstore(0x00, m0)
    11222
                mstore(0x20, m1)
    11223
                mstore(0x40, m2)
    11224
                mstore(0x60, m3)
    11225
                mstore(0x80, m4)
    11226
                mstore(0xa0, m5)
    11227
                mstore(0xc0, m6)
    11228
            }
    11229
        }
    11230
    11231
        function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {
    11232
            bytes32 m0;
    11233
            bytes32 m1;
    11234
            bytes32 m2;
    11235
            bytes32 m3;
    11236
            bytes32 m4;
    11237
            bytes32 m5;
    11238
            bytes32 m6;
    11239
            bytes32 m7;
    11240
            bytes32 m8;
    11241
            /// @solidity memory-safe-assembly
    11242
            assembly {
    11243
                function writeString(pos, w) {
    11244
                    let length := 0
    11245
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11246
                    mstore(pos, length)
    11247
                    let shift := sub(256, shl(3, length))
    11248
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11249
                }
    11250
                m0 := mload(0x00)
    11251
                m1 := mload(0x20)
    11252
                m2 := mload(0x40)
    11253
                m3 := mload(0x60)
    11254
                m4 := mload(0x80)
    11255
                m5 := mload(0xa0)
    11256
                m6 := mload(0xc0)
    11257
                m7 := mload(0xe0)
    11258
                m8 := mload(0x100)
    11259
                // Selector of `log(string,address,uint256,string)`.
    11260
                mstore(0x00, 0x5a477632)
    11261
                mstore(0x20, 0x80)
    11262
                mstore(0x40, p1)
    11263
                mstore(0x60, p2)
    11264
                mstore(0x80, 0xc0)
    11265
                writeString(0xa0, p0)
    11266
                writeString(0xe0, p3)
    11267
            }
    11268
            _sendLogPayload(0x1c, 0x104);
    11269
            /// @solidity memory-safe-assembly
    11270
            assembly {
    11271
                mstore(0x00, m0)
    11272
                mstore(0x20, m1)
    11273
                mstore(0x40, m2)
    11274
                mstore(0x60, m3)
    11275
                mstore(0x80, m4)
    11276
                mstore(0xa0, m5)
    11277
                mstore(0xc0, m6)
    11278
                mstore(0xe0, m7)
    11279
                mstore(0x100, m8)
    11280
            }
    11281
        }
    11282
    11283
        function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {
    11284
            bytes32 m0;
    11285
            bytes32 m1;
    11286
            bytes32 m2;
    11287
            bytes32 m3;
    11288
            bytes32 m4;
    11289
            bytes32 m5;
    11290
            bytes32 m6;
    11291
            bytes32 m7;
    11292
            bytes32 m8;
    11293
            /// @solidity memory-safe-assembly
    11294
            assembly {
    11295
                function writeString(pos, w) {
    11296
                    let length := 0
    11297
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11298
                    mstore(pos, length)
    11299
                    let shift := sub(256, shl(3, length))
    11300
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11301
                }
    11302
                m0 := mload(0x00)
    11303
                m1 := mload(0x20)
    11304
                m2 := mload(0x40)
    11305
                m3 := mload(0x60)
    11306
                m4 := mload(0x80)
    11307
                m5 := mload(0xa0)
    11308
                m6 := mload(0xc0)
    11309
                m7 := mload(0xe0)
    11310
                m8 := mload(0x100)
    11311
                // Selector of `log(string,address,string,address)`.
    11312
                mstore(0x00, 0xaabc9a31)
    11313
                mstore(0x20, 0x80)
    11314
                mstore(0x40, p1)
    11315
                mstore(0x60, 0xc0)
    11316
                mstore(0x80, p3)
    11317
                writeString(0xa0, p0)
    11318
                writeString(0xe0, p2)
    11319
            }
    11320
            _sendLogPayload(0x1c, 0x104);
    11321
            /// @solidity memory-safe-assembly
    11322
            assembly {
    11323
                mstore(0x00, m0)
    11324
                mstore(0x20, m1)
    11325
                mstore(0x40, m2)
    11326
                mstore(0x60, m3)
    11327
                mstore(0x80, m4)
    11328
                mstore(0xa0, m5)
    11329
                mstore(0xc0, m6)
    11330
                mstore(0xe0, m7)
    11331
                mstore(0x100, m8)
    11332
            }
    11333
        }
    11334
    11335
        function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {
    11336
            bytes32 m0;
    11337
            bytes32 m1;
    11338
            bytes32 m2;
    11339
            bytes32 m3;
    11340
            bytes32 m4;
    11341
            bytes32 m5;
    11342
            bytes32 m6;
    11343
            bytes32 m7;
    11344
            bytes32 m8;
    11345
            /// @solidity memory-safe-assembly
    11346
            assembly {
    11347
                function writeString(pos, w) {
    11348
                    let length := 0
    11349
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11350
                    mstore(pos, length)
    11351
                    let shift := sub(256, shl(3, length))
    11352
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11353
                }
    11354
                m0 := mload(0x00)
    11355
                m1 := mload(0x20)
    11356
                m2 := mload(0x40)
    11357
                m3 := mload(0x60)
    11358
                m4 := mload(0x80)
    11359
                m5 := mload(0xa0)
    11360
                m6 := mload(0xc0)
    11361
                m7 := mload(0xe0)
    11362
                m8 := mload(0x100)
    11363
                // Selector of `log(string,address,string,bool)`.
    11364
                mstore(0x00, 0x5f15d28c)
    11365
                mstore(0x20, 0x80)
    11366
                mstore(0x40, p1)
    11367
                mstore(0x60, 0xc0)
    11368
                mstore(0x80, p3)
    11369
                writeString(0xa0, p0)
    11370
                writeString(0xe0, p2)
    11371
            }
    11372
            _sendLogPayload(0x1c, 0x104);
    11373
            /// @solidity memory-safe-assembly
    11374
            assembly {
    11375
                mstore(0x00, m0)
    11376
                mstore(0x20, m1)
    11377
                mstore(0x40, m2)
    11378
                mstore(0x60, m3)
    11379
                mstore(0x80, m4)
    11380
                mstore(0xa0, m5)
    11381
                mstore(0xc0, m6)
    11382
                mstore(0xe0, m7)
    11383
                mstore(0x100, m8)
    11384
            }
    11385
        }
    11386
    11387
        function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {
    11388
            bytes32 m0;
    11389
            bytes32 m1;
    11390
            bytes32 m2;
    11391
            bytes32 m3;
    11392
            bytes32 m4;
    11393
            bytes32 m5;
    11394
            bytes32 m6;
    11395
            bytes32 m7;
    11396
            bytes32 m8;
    11397
            /// @solidity memory-safe-assembly
    11398
            assembly {
    11399
                function writeString(pos, w) {
    11400
                    let length := 0
    11401
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11402
                    mstore(pos, length)
    11403
                    let shift := sub(256, shl(3, length))
    11404
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11405
                }
    11406
                m0 := mload(0x00)
    11407
                m1 := mload(0x20)
    11408
                m2 := mload(0x40)
    11409
                m3 := mload(0x60)
    11410
                m4 := mload(0x80)
    11411
                m5 := mload(0xa0)
    11412
                m6 := mload(0xc0)
    11413
                m7 := mload(0xe0)
    11414
                m8 := mload(0x100)
    11415
                // Selector of `log(string,address,string,uint256)`.
    11416
                mstore(0x00, 0x91d1112e)
    11417
                mstore(0x20, 0x80)
    11418
                mstore(0x40, p1)
    11419
                mstore(0x60, 0xc0)
    11420
                mstore(0x80, p3)
    11421
                writeString(0xa0, p0)
    11422
                writeString(0xe0, p2)
    11423
            }
    11424
            _sendLogPayload(0x1c, 0x104);
    11425
            /// @solidity memory-safe-assembly
    11426
            assembly {
    11427
                mstore(0x00, m0)
    11428
                mstore(0x20, m1)
    11429
                mstore(0x40, m2)
    11430
                mstore(0x60, m3)
    11431
                mstore(0x80, m4)
    11432
                mstore(0xa0, m5)
    11433
                mstore(0xc0, m6)
    11434
                mstore(0xe0, m7)
    11435
                mstore(0x100, m8)
    11436
            }
    11437
        }
    11438
    11439
        function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
    11440
            bytes32 m0;
    11441
            bytes32 m1;
    11442
            bytes32 m2;
    11443
            bytes32 m3;
    11444
            bytes32 m4;
    11445
            bytes32 m5;
    11446
            bytes32 m6;
    11447
            bytes32 m7;
    11448
            bytes32 m8;
    11449
            bytes32 m9;
    11450
            bytes32 m10;
    11451
            /// @solidity memory-safe-assembly
    11452
            assembly {
    11453
                function writeString(pos, w) {
    11454
                    let length := 0
    11455
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11456
                    mstore(pos, length)
    11457
                    let shift := sub(256, shl(3, length))
    11458
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11459
                }
    11460
                m0 := mload(0x00)
    11461
                m1 := mload(0x20)
    11462
                m2 := mload(0x40)
    11463
                m3 := mload(0x60)
    11464
                m4 := mload(0x80)
    11465
                m5 := mload(0xa0)
    11466
                m6 := mload(0xc0)
    11467
                m7 := mload(0xe0)
    11468
                m8 := mload(0x100)
    11469
                m9 := mload(0x120)
    11470
                m10 := mload(0x140)
    11471
                // Selector of `log(string,address,string,string)`.
    11472
                mstore(0x00, 0x245986f2)
    11473
                mstore(0x20, 0x80)
    11474
                mstore(0x40, p1)
    11475
                mstore(0x60, 0xc0)
    11476
                mstore(0x80, 0x100)
    11477
                writeString(0xa0, p0)
    11478
                writeString(0xe0, p2)
    11479
                writeString(0x120, p3)
    11480
            }
    11481
            _sendLogPayload(0x1c, 0x144);
    11482
            /// @solidity memory-safe-assembly
    11483
            assembly {
    11484
                mstore(0x00, m0)
    11485
                mstore(0x20, m1)
    11486
                mstore(0x40, m2)
    11487
                mstore(0x60, m3)
    11488
                mstore(0x80, m4)
    11489
                mstore(0xa0, m5)
    11490
                mstore(0xc0, m6)
    11491
                mstore(0xe0, m7)
    11492
                mstore(0x100, m8)
    11493
                mstore(0x120, m9)
    11494
                mstore(0x140, m10)
    11495
            }
    11496
        }
    11497
    11498
        function log(bytes32 p0, bool p1, address p2, address p3) internal pure {
    11499
            bytes32 m0;
    11500
            bytes32 m1;
    11501
            bytes32 m2;
    11502
            bytes32 m3;
    11503
            bytes32 m4;
    11504
            bytes32 m5;
    11505
            bytes32 m6;
    11506
            /// @solidity memory-safe-assembly
    11507
            assembly {
    11508
                function writeString(pos, w) {
    11509
                    let length := 0
    11510
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11511
                    mstore(pos, length)
    11512
                    let shift := sub(256, shl(3, length))
    11513
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11514
                }
    11515
                m0 := mload(0x00)
    11516
                m1 := mload(0x20)
    11517
                m2 := mload(0x40)
    11518
                m3 := mload(0x60)
    11519
                m4 := mload(0x80)
    11520
                m5 := mload(0xa0)
    11521
                m6 := mload(0xc0)
    11522
                // Selector of `log(string,bool,address,address)`.
    11523
                mstore(0x00, 0x33e9dd1d)
    11524
                mstore(0x20, 0x80)
    11525
                mstore(0x40, p1)
    11526
                mstore(0x60, p2)
    11527
                mstore(0x80, p3)
    11528
                writeString(0xa0, p0)
    11529
            }
    11530
            _sendLogPayload(0x1c, 0xc4);
    11531
            /// @solidity memory-safe-assembly
    11532
            assembly {
    11533
                mstore(0x00, m0)
    11534
                mstore(0x20, m1)
    11535
                mstore(0x40, m2)
    11536
                mstore(0x60, m3)
    11537
                mstore(0x80, m4)
    11538
                mstore(0xa0, m5)
    11539
                mstore(0xc0, m6)
    11540
            }
    11541
        }
    11542
    11543
        function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {
    11544
            bytes32 m0;
    11545
            bytes32 m1;
    11546
            bytes32 m2;
    11547
            bytes32 m3;
    11548
            bytes32 m4;
    11549
            bytes32 m5;
    11550
            bytes32 m6;
    11551
            /// @solidity memory-safe-assembly
    11552
            assembly {
    11553
                function writeString(pos, w) {
    11554
                    let length := 0
    11555
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11556
                    mstore(pos, length)
    11557
                    let shift := sub(256, shl(3, length))
    11558
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11559
                }
    11560
                m0 := mload(0x00)
    11561
                m1 := mload(0x20)
    11562
                m2 := mload(0x40)
    11563
                m3 := mload(0x60)
    11564
                m4 := mload(0x80)
    11565
                m5 := mload(0xa0)
    11566
                m6 := mload(0xc0)
    11567
                // Selector of `log(string,bool,address,bool)`.
    11568
                mstore(0x00, 0x958c28c6)
    11569
                mstore(0x20, 0x80)
    11570
                mstore(0x40, p1)
    11571
                mstore(0x60, p2)
    11572
                mstore(0x80, p3)
    11573
                writeString(0xa0, p0)
    11574
            }
    11575
            _sendLogPayload(0x1c, 0xc4);
    11576
            /// @solidity memory-safe-assembly
    11577
            assembly {
    11578
                mstore(0x00, m0)
    11579
                mstore(0x20, m1)
    11580
                mstore(0x40, m2)
    11581
                mstore(0x60, m3)
    11582
                mstore(0x80, m4)
    11583
                mstore(0xa0, m5)
    11584
                mstore(0xc0, m6)
    11585
            }
    11586
        }
    11587
    11588
        function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {
    11589
            bytes32 m0;
    11590
            bytes32 m1;
    11591
            bytes32 m2;
    11592
            bytes32 m3;
    11593
            bytes32 m4;
    11594
            bytes32 m5;
    11595
            bytes32 m6;
    11596
            /// @solidity memory-safe-assembly
    11597
            assembly {
    11598
                function writeString(pos, w) {
    11599
                    let length := 0
    11600
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11601
                    mstore(pos, length)
    11602
                    let shift := sub(256, shl(3, length))
    11603
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11604
                }
    11605
                m0 := mload(0x00)
    11606
                m1 := mload(0x20)
    11607
                m2 := mload(0x40)
    11608
                m3 := mload(0x60)
    11609
                m4 := mload(0x80)
    11610
                m5 := mload(0xa0)
    11611
                m6 := mload(0xc0)
    11612
                // Selector of `log(string,bool,address,uint256)`.
    11613
                mstore(0x00, 0x5d08bb05)
    11614
                mstore(0x20, 0x80)
    11615
                mstore(0x40, p1)
    11616
                mstore(0x60, p2)
    11617
                mstore(0x80, p3)
    11618
                writeString(0xa0, p0)
    11619
            }
    11620
            _sendLogPayload(0x1c, 0xc4);
    11621
            /// @solidity memory-safe-assembly
    11622
            assembly {
    11623
                mstore(0x00, m0)
    11624
                mstore(0x20, m1)
    11625
                mstore(0x40, m2)
    11626
                mstore(0x60, m3)
    11627
                mstore(0x80, m4)
    11628
                mstore(0xa0, m5)
    11629
                mstore(0xc0, m6)
    11630
            }
    11631
        }
    11632
    11633
        function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {
    11634
            bytes32 m0;
    11635
            bytes32 m1;
    11636
            bytes32 m2;
    11637
            bytes32 m3;
    11638
            bytes32 m4;
    11639
            bytes32 m5;
    11640
            bytes32 m6;
    11641
            bytes32 m7;
    11642
            bytes32 m8;
    11643
            /// @solidity memory-safe-assembly
    11644
            assembly {
    11645
                function writeString(pos, w) {
    11646
                    let length := 0
    11647
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11648
                    mstore(pos, length)
    11649
                    let shift := sub(256, shl(3, length))
    11650
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11651
                }
    11652
                m0 := mload(0x00)
    11653
                m1 := mload(0x20)
    11654
                m2 := mload(0x40)
    11655
                m3 := mload(0x60)
    11656
                m4 := mload(0x80)
    11657
                m5 := mload(0xa0)
    11658
                m6 := mload(0xc0)
    11659
                m7 := mload(0xe0)
    11660
                m8 := mload(0x100)
    11661
                // Selector of `log(string,bool,address,string)`.
    11662
                mstore(0x00, 0x2d8e33a4)
    11663
                mstore(0x20, 0x80)
    11664
                mstore(0x40, p1)
    11665
                mstore(0x60, p2)
    11666
                mstore(0x80, 0xc0)
    11667
                writeString(0xa0, p0)
    11668
                writeString(0xe0, p3)
    11669
            }
    11670
            _sendLogPayload(0x1c, 0x104);
    11671
            /// @solidity memory-safe-assembly
    11672
            assembly {
    11673
                mstore(0x00, m0)
    11674
                mstore(0x20, m1)
    11675
                mstore(0x40, m2)
    11676
                mstore(0x60, m3)
    11677
                mstore(0x80, m4)
    11678
                mstore(0xa0, m5)
    11679
                mstore(0xc0, m6)
    11680
                mstore(0xe0, m7)
    11681
                mstore(0x100, m8)
    11682
            }
    11683
        }
    11684
    11685
        function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {
    11686
            bytes32 m0;
    11687
            bytes32 m1;
    11688
            bytes32 m2;
    11689
            bytes32 m3;
    11690
            bytes32 m4;
    11691
            bytes32 m5;
    11692
            bytes32 m6;
    11693
            /// @solidity memory-safe-assembly
    11694
            assembly {
    11695
                function writeString(pos, w) {
    11696
                    let length := 0
    11697
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11698
                    mstore(pos, length)
    11699
                    let shift := sub(256, shl(3, length))
    11700
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11701
                }
    11702
                m0 := mload(0x00)
    11703
                m1 := mload(0x20)
    11704
                m2 := mload(0x40)
    11705
                m3 := mload(0x60)
    11706
                m4 := mload(0x80)
    11707
                m5 := mload(0xa0)
    11708
                m6 := mload(0xc0)
    11709
                // Selector of `log(string,bool,bool,address)`.
    11710
                mstore(0x00, 0x7190a529)
    11711
                mstore(0x20, 0x80)
    11712
                mstore(0x40, p1)
    11713
                mstore(0x60, p2)
    11714
                mstore(0x80, p3)
    11715
                writeString(0xa0, p0)
    11716
            }
    11717
            _sendLogPayload(0x1c, 0xc4);
    11718
            /// @solidity memory-safe-assembly
    11719
            assembly {
    11720
                mstore(0x00, m0)
    11721
                mstore(0x20, m1)
    11722
                mstore(0x40, m2)
    11723
                mstore(0x60, m3)
    11724
                mstore(0x80, m4)
    11725
                mstore(0xa0, m5)
    11726
                mstore(0xc0, m6)
    11727
            }
    11728
        }
    11729
    11730
        function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {
    11731
            bytes32 m0;
    11732
            bytes32 m1;
    11733
            bytes32 m2;
    11734
            bytes32 m3;
    11735
            bytes32 m4;
    11736
            bytes32 m5;
    11737
            bytes32 m6;
    11738
            /// @solidity memory-safe-assembly
    11739
            assembly {
    11740
                function writeString(pos, w) {
    11741
                    let length := 0
    11742
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11743
                    mstore(pos, length)
    11744
                    let shift := sub(256, shl(3, length))
    11745
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11746
                }
    11747
                m0 := mload(0x00)
    11748
                m1 := mload(0x20)
    11749
                m2 := mload(0x40)
    11750
                m3 := mload(0x60)
    11751
                m4 := mload(0x80)
    11752
                m5 := mload(0xa0)
    11753
                m6 := mload(0xc0)
    11754
                // Selector of `log(string,bool,bool,bool)`.
    11755
                mstore(0x00, 0x895af8c5)
    11756
                mstore(0x20, 0x80)
    11757
                mstore(0x40, p1)
    11758
                mstore(0x60, p2)
    11759
                mstore(0x80, p3)
    11760
                writeString(0xa0, p0)
    11761
            }
    11762
            _sendLogPayload(0x1c, 0xc4);
    11763
            /// @solidity memory-safe-assembly
    11764
            assembly {
    11765
                mstore(0x00, m0)
    11766
                mstore(0x20, m1)
    11767
                mstore(0x40, m2)
    11768
                mstore(0x60, m3)
    11769
                mstore(0x80, m4)
    11770
                mstore(0xa0, m5)
    11771
                mstore(0xc0, m6)
    11772
            }
    11773
        }
    11774
    11775
        function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {
    11776
            bytes32 m0;
    11777
            bytes32 m1;
    11778
            bytes32 m2;
    11779
            bytes32 m3;
    11780
            bytes32 m4;
    11781
            bytes32 m5;
    11782
            bytes32 m6;
    11783
            /// @solidity memory-safe-assembly
    11784
            assembly {
    11785
                function writeString(pos, w) {
    11786
                    let length := 0
    11787
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11788
                    mstore(pos, length)
    11789
                    let shift := sub(256, shl(3, length))
    11790
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11791
                }
    11792
                m0 := mload(0x00)
    11793
                m1 := mload(0x20)
    11794
                m2 := mload(0x40)
    11795
                m3 := mload(0x60)
    11796
                m4 := mload(0x80)
    11797
                m5 := mload(0xa0)
    11798
                m6 := mload(0xc0)
    11799
                // Selector of `log(string,bool,bool,uint256)`.
    11800
                mstore(0x00, 0x8e3f78a9)
    11801
                mstore(0x20, 0x80)
    11802
                mstore(0x40, p1)
    11803
                mstore(0x60, p2)
    11804
                mstore(0x80, p3)
    11805
                writeString(0xa0, p0)
    11806
            }
    11807
            _sendLogPayload(0x1c, 0xc4);
    11808
            /// @solidity memory-safe-assembly
    11809
            assembly {
    11810
                mstore(0x00, m0)
    11811
                mstore(0x20, m1)
    11812
                mstore(0x40, m2)
    11813
                mstore(0x60, m3)
    11814
                mstore(0x80, m4)
    11815
                mstore(0xa0, m5)
    11816
                mstore(0xc0, m6)
    11817
            }
    11818
        }
    11819
    11820
        function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {
    11821
            bytes32 m0;
    11822
            bytes32 m1;
    11823
            bytes32 m2;
    11824
            bytes32 m3;
    11825
            bytes32 m4;
    11826
            bytes32 m5;
    11827
            bytes32 m6;
    11828
            bytes32 m7;
    11829
            bytes32 m8;
    11830
            /// @solidity memory-safe-assembly
    11831
            assembly {
    11832
                function writeString(pos, w) {
    11833
                    let length := 0
    11834
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11835
                    mstore(pos, length)
    11836
                    let shift := sub(256, shl(3, length))
    11837
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11838
                }
    11839
                m0 := mload(0x00)
    11840
                m1 := mload(0x20)
    11841
                m2 := mload(0x40)
    11842
                m3 := mload(0x60)
    11843
                m4 := mload(0x80)
    11844
                m5 := mload(0xa0)
    11845
                m6 := mload(0xc0)
    11846
                m7 := mload(0xe0)
    11847
                m8 := mload(0x100)
    11848
                // Selector of `log(string,bool,bool,string)`.
    11849
                mstore(0x00, 0x9d22d5dd)
    11850
                mstore(0x20, 0x80)
    11851
                mstore(0x40, p1)
    11852
                mstore(0x60, p2)
    11853
                mstore(0x80, 0xc0)
    11854
                writeString(0xa0, p0)
    11855
                writeString(0xe0, p3)
    11856
            }
    11857
            _sendLogPayload(0x1c, 0x104);
    11858
            /// @solidity memory-safe-assembly
    11859
            assembly {
    11860
                mstore(0x00, m0)
    11861
                mstore(0x20, m1)
    11862
                mstore(0x40, m2)
    11863
                mstore(0x60, m3)
    11864
                mstore(0x80, m4)
    11865
                mstore(0xa0, m5)
    11866
                mstore(0xc0, m6)
    11867
                mstore(0xe0, m7)
    11868
                mstore(0x100, m8)
    11869
            }
    11870
        }
    11871
    11872
        function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {
    11873
            bytes32 m0;
    11874
            bytes32 m1;
    11875
            bytes32 m2;
    11876
            bytes32 m3;
    11877
            bytes32 m4;
    11878
            bytes32 m5;
    11879
            bytes32 m6;
    11880
            /// @solidity memory-safe-assembly
    11881
            assembly {
    11882
                function writeString(pos, w) {
    11883
                    let length := 0
    11884
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11885
                    mstore(pos, length)
    11886
                    let shift := sub(256, shl(3, length))
    11887
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11888
                }
    11889
                m0 := mload(0x00)
    11890
                m1 := mload(0x20)
    11891
                m2 := mload(0x40)
    11892
                m3 := mload(0x60)
    11893
                m4 := mload(0x80)
    11894
                m5 := mload(0xa0)
    11895
                m6 := mload(0xc0)
    11896
                // Selector of `log(string,bool,uint256,address)`.
    11897
                mstore(0x00, 0x935e09bf)
    11898
                mstore(0x20, 0x80)
    11899
                mstore(0x40, p1)
    11900
                mstore(0x60, p2)
    11901
                mstore(0x80, p3)
    11902
                writeString(0xa0, p0)
    11903
            }
    11904
            _sendLogPayload(0x1c, 0xc4);
    11905
            /// @solidity memory-safe-assembly
    11906
            assembly {
    11907
                mstore(0x00, m0)
    11908
                mstore(0x20, m1)
    11909
                mstore(0x40, m2)
    11910
                mstore(0x60, m3)
    11911
                mstore(0x80, m4)
    11912
                mstore(0xa0, m5)
    11913
                mstore(0xc0, m6)
    11914
            }
    11915
        }
    11916
    11917
        function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {
    11918
            bytes32 m0;
    11919
            bytes32 m1;
    11920
            bytes32 m2;
    11921
            bytes32 m3;
    11922
            bytes32 m4;
    11923
            bytes32 m5;
    11924
            bytes32 m6;
    11925
            /// @solidity memory-safe-assembly
    11926
            assembly {
    11927
                function writeString(pos, w) {
    11928
                    let length := 0
    11929
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11930
                    mstore(pos, length)
    11931
                    let shift := sub(256, shl(3, length))
    11932
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11933
                }
    11934
                m0 := mload(0x00)
    11935
                m1 := mload(0x20)
    11936
                m2 := mload(0x40)
    11937
                m3 := mload(0x60)
    11938
                m4 := mload(0x80)
    11939
                m5 := mload(0xa0)
    11940
                m6 := mload(0xc0)
    11941
                // Selector of `log(string,bool,uint256,bool)`.
    11942
                mstore(0x00, 0x8af7cf8a)
    11943
                mstore(0x20, 0x80)
    11944
                mstore(0x40, p1)
    11945
                mstore(0x60, p2)
    11946
                mstore(0x80, p3)
    11947
                writeString(0xa0, p0)
    11948
            }
    11949
            _sendLogPayload(0x1c, 0xc4);
    11950
            /// @solidity memory-safe-assembly
    11951
            assembly {
    11952
                mstore(0x00, m0)
    11953
                mstore(0x20, m1)
    11954
                mstore(0x40, m2)
    11955
                mstore(0x60, m3)
    11956
                mstore(0x80, m4)
    11957
                mstore(0xa0, m5)
    11958
                mstore(0xc0, m6)
    11959
            }
    11960
        }
    11961
    11962
        function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {
    11963
            bytes32 m0;
    11964
            bytes32 m1;
    11965
            bytes32 m2;
    11966
            bytes32 m3;
    11967
            bytes32 m4;
    11968
            bytes32 m5;
    11969
            bytes32 m6;
    11970
            /// @solidity memory-safe-assembly
    11971
            assembly {
    11972
                function writeString(pos, w) {
    11973
                    let length := 0
    11974
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    11975
                    mstore(pos, length)
    11976
                    let shift := sub(256, shl(3, length))
    11977
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    11978
                }
    11979
                m0 := mload(0x00)
    11980
                m1 := mload(0x20)
    11981
                m2 := mload(0x40)
    11982
                m3 := mload(0x60)
    11983
                m4 := mload(0x80)
    11984
                m5 := mload(0xa0)
    11985
                m6 := mload(0xc0)
    11986
                // Selector of `log(string,bool,uint256,uint256)`.
    11987
                mstore(0x00, 0x64b5bb67)
    11988
                mstore(0x20, 0x80)
    11989
                mstore(0x40, p1)
    11990
                mstore(0x60, p2)
    11991
                mstore(0x80, p3)
    11992
                writeString(0xa0, p0)
    11993
            }
    11994
            _sendLogPayload(0x1c, 0xc4);
    11995
            /// @solidity memory-safe-assembly
    11996
            assembly {
    11997
                mstore(0x00, m0)
    11998
                mstore(0x20, m1)
    11999
                mstore(0x40, m2)
    12000
                mstore(0x60, m3)
    12001
                mstore(0x80, m4)
    12002
                mstore(0xa0, m5)
    12003
                mstore(0xc0, m6)
    12004
            }
    12005
        }
    12006
    12007
        function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
    12008
            bytes32 m0;
    12009
            bytes32 m1;
    12010
            bytes32 m2;
    12011
            bytes32 m3;
    12012
            bytes32 m4;
    12013
            bytes32 m5;
    12014
            bytes32 m6;
    12015
            bytes32 m7;
    12016
            bytes32 m8;
    12017
            /// @solidity memory-safe-assembly
    12018
            assembly {
    12019
                function writeString(pos, w) {
    12020
                    let length := 0
    12021
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12022
                    mstore(pos, length)
    12023
                    let shift := sub(256, shl(3, length))
    12024
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12025
                }
    12026
                m0 := mload(0x00)
    12027
                m1 := mload(0x20)
    12028
                m2 := mload(0x40)
    12029
                m3 := mload(0x60)
    12030
                m4 := mload(0x80)
    12031
                m5 := mload(0xa0)
    12032
                m6 := mload(0xc0)
    12033
                m7 := mload(0xe0)
    12034
                m8 := mload(0x100)
    12035
                // Selector of `log(string,bool,uint256,string)`.
    12036
                mstore(0x00, 0x742d6ee7)
    12037
                mstore(0x20, 0x80)
    12038
                mstore(0x40, p1)
    12039
                mstore(0x60, p2)
    12040
                mstore(0x80, 0xc0)
    12041
                writeString(0xa0, p0)
    12042
                writeString(0xe0, p3)
    12043
            }
    12044
            _sendLogPayload(0x1c, 0x104);
    12045
            /// @solidity memory-safe-assembly
    12046
            assembly {
    12047
                mstore(0x00, m0)
    12048
                mstore(0x20, m1)
    12049
                mstore(0x40, m2)
    12050
                mstore(0x60, m3)
    12051
                mstore(0x80, m4)
    12052
                mstore(0xa0, m5)
    12053
                mstore(0xc0, m6)
    12054
                mstore(0xe0, m7)
    12055
                mstore(0x100, m8)
    12056
            }
    12057
        }
    12058
    12059
        function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {
    12060
            bytes32 m0;
    12061
            bytes32 m1;
    12062
            bytes32 m2;
    12063
            bytes32 m3;
    12064
            bytes32 m4;
    12065
            bytes32 m5;
    12066
            bytes32 m6;
    12067
            bytes32 m7;
    12068
            bytes32 m8;
    12069
            /// @solidity memory-safe-assembly
    12070
            assembly {
    12071
                function writeString(pos, w) {
    12072
                    let length := 0
    12073
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12074
                    mstore(pos, length)
    12075
                    let shift := sub(256, shl(3, length))
    12076
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12077
                }
    12078
                m0 := mload(0x00)
    12079
                m1 := mload(0x20)
    12080
                m2 := mload(0x40)
    12081
                m3 := mload(0x60)
    12082
                m4 := mload(0x80)
    12083
                m5 := mload(0xa0)
    12084
                m6 := mload(0xc0)
    12085
                m7 := mload(0xe0)
    12086
                m8 := mload(0x100)
    12087
                // Selector of `log(string,bool,string,address)`.
    12088
                mstore(0x00, 0xe0625b29)
    12089
                mstore(0x20, 0x80)
    12090
                mstore(0x40, p1)
    12091
                mstore(0x60, 0xc0)
    12092
                mstore(0x80, p3)
    12093
                writeString(0xa0, p0)
    12094
                writeString(0xe0, p2)
    12095
            }
    12096
            _sendLogPayload(0x1c, 0x104);
    12097
            /// @solidity memory-safe-assembly
    12098
            assembly {
    12099
                mstore(0x00, m0)
    12100
                mstore(0x20, m1)
    12101
                mstore(0x40, m2)
    12102
                mstore(0x60, m3)
    12103
                mstore(0x80, m4)
    12104
                mstore(0xa0, m5)
    12105
                mstore(0xc0, m6)
    12106
                mstore(0xe0, m7)
    12107
                mstore(0x100, m8)
    12108
            }
    12109
        }
    12110
    12111
        function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {
    12112
            bytes32 m0;
    12113
            bytes32 m1;
    12114
            bytes32 m2;
    12115
            bytes32 m3;
    12116
            bytes32 m4;
    12117
            bytes32 m5;
    12118
            bytes32 m6;
    12119
            bytes32 m7;
    12120
            bytes32 m8;
    12121
            /// @solidity memory-safe-assembly
    12122
            assembly {
    12123
                function writeString(pos, w) {
    12124
                    let length := 0
    12125
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12126
                    mstore(pos, length)
    12127
                    let shift := sub(256, shl(3, length))
    12128
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12129
                }
    12130
                m0 := mload(0x00)
    12131
                m1 := mload(0x20)
    12132
                m2 := mload(0x40)
    12133
                m3 := mload(0x60)
    12134
                m4 := mload(0x80)
    12135
                m5 := mload(0xa0)
    12136
                m6 := mload(0xc0)
    12137
                m7 := mload(0xe0)
    12138
                m8 := mload(0x100)
    12139
                // Selector of `log(string,bool,string,bool)`.
    12140
                mstore(0x00, 0x3f8a701d)
    12141
                mstore(0x20, 0x80)
    12142
                mstore(0x40, p1)
    12143
                mstore(0x60, 0xc0)
    12144
                mstore(0x80, p3)
    12145
                writeString(0xa0, p0)
    12146
                writeString(0xe0, p2)
    12147
            }
    12148
            _sendLogPayload(0x1c, 0x104);
    12149
            /// @solidity memory-safe-assembly
    12150
            assembly {
    12151
                mstore(0x00, m0)
    12152
                mstore(0x20, m1)
    12153
                mstore(0x40, m2)
    12154
                mstore(0x60, m3)
    12155
                mstore(0x80, m4)
    12156
                mstore(0xa0, m5)
    12157
                mstore(0xc0, m6)
    12158
                mstore(0xe0, m7)
    12159
                mstore(0x100, m8)
    12160
            }
    12161
        }
    12162
    12163
        function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
    12164
            bytes32 m0;
    12165
            bytes32 m1;
    12166
            bytes32 m2;
    12167
            bytes32 m3;
    12168
            bytes32 m4;
    12169
            bytes32 m5;
    12170
            bytes32 m6;
    12171
            bytes32 m7;
    12172
            bytes32 m8;
    12173
            /// @solidity memory-safe-assembly
    12174
            assembly {
    12175
                function writeString(pos, w) {
    12176
                    let length := 0
    12177
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12178
                    mstore(pos, length)
    12179
                    let shift := sub(256, shl(3, length))
    12180
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12181
                }
    12182
                m0 := mload(0x00)
    12183
                m1 := mload(0x20)
    12184
                m2 := mload(0x40)
    12185
                m3 := mload(0x60)
    12186
                m4 := mload(0x80)
    12187
                m5 := mload(0xa0)
    12188
                m6 := mload(0xc0)
    12189
                m7 := mload(0xe0)
    12190
                m8 := mload(0x100)
    12191
                // Selector of `log(string,bool,string,uint256)`.
    12192
                mstore(0x00, 0x24f91465)
    12193
                mstore(0x20, 0x80)
    12194
                mstore(0x40, p1)
    12195
                mstore(0x60, 0xc0)
    12196
                mstore(0x80, p3)
    12197
                writeString(0xa0, p0)
    12198
                writeString(0xe0, p2)
    12199
            }
    12200
            _sendLogPayload(0x1c, 0x104);
    12201
            /// @solidity memory-safe-assembly
    12202
            assembly {
    12203
                mstore(0x00, m0)
    12204
                mstore(0x20, m1)
    12205
                mstore(0x40, m2)
    12206
                mstore(0x60, m3)
    12207
                mstore(0x80, m4)
    12208
                mstore(0xa0, m5)
    12209
                mstore(0xc0, m6)
    12210
                mstore(0xe0, m7)
    12211
                mstore(0x100, m8)
    12212
            }
    12213
        }
    12214
    12215
        function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
    12216
            bytes32 m0;
    12217
            bytes32 m1;
    12218
            bytes32 m2;
    12219
            bytes32 m3;
    12220
            bytes32 m4;
    12221
            bytes32 m5;
    12222
            bytes32 m6;
    12223
            bytes32 m7;
    12224
            bytes32 m8;
    12225
            bytes32 m9;
    12226
            bytes32 m10;
    12227
            /// @solidity memory-safe-assembly
    12228
            assembly {
    12229
                function writeString(pos, w) {
    12230
                    let length := 0
    12231
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12232
                    mstore(pos, length)
    12233
                    let shift := sub(256, shl(3, length))
    12234
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12235
                }
    12236
                m0 := mload(0x00)
    12237
                m1 := mload(0x20)
    12238
                m2 := mload(0x40)
    12239
                m3 := mload(0x60)
    12240
                m4 := mload(0x80)
    12241
                m5 := mload(0xa0)
    12242
                m6 := mload(0xc0)
    12243
                m7 := mload(0xe0)
    12244
                m8 := mload(0x100)
    12245
                m9 := mload(0x120)
    12246
                m10 := mload(0x140)
    12247
                // Selector of `log(string,bool,string,string)`.
    12248
                mstore(0x00, 0xa826caeb)
    12249
                mstore(0x20, 0x80)
    12250
                mstore(0x40, p1)
    12251
                mstore(0x60, 0xc0)
    12252
                mstore(0x80, 0x100)
    12253
                writeString(0xa0, p0)
    12254
                writeString(0xe0, p2)
    12255
                writeString(0x120, p3)
    12256
            }
    12257
            _sendLogPayload(0x1c, 0x144);
    12258
            /// @solidity memory-safe-assembly
    12259
            assembly {
    12260
                mstore(0x00, m0)
    12261
                mstore(0x20, m1)
    12262
                mstore(0x40, m2)
    12263
                mstore(0x60, m3)
    12264
                mstore(0x80, m4)
    12265
                mstore(0xa0, m5)
    12266
                mstore(0xc0, m6)
    12267
                mstore(0xe0, m7)
    12268
                mstore(0x100, m8)
    12269
                mstore(0x120, m9)
    12270
                mstore(0x140, m10)
    12271
            }
    12272
        }
    12273
    12274
        function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {
    12275
            bytes32 m0;
    12276
            bytes32 m1;
    12277
            bytes32 m2;
    12278
            bytes32 m3;
    12279
            bytes32 m4;
    12280
            bytes32 m5;
    12281
            bytes32 m6;
    12282
            /// @solidity memory-safe-assembly
    12283
            assembly {
    12284
                function writeString(pos, w) {
    12285
                    let length := 0
    12286
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12287
                    mstore(pos, length)
    12288
                    let shift := sub(256, shl(3, length))
    12289
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12290
                }
    12291
                m0 := mload(0x00)
    12292
                m1 := mload(0x20)
    12293
                m2 := mload(0x40)
    12294
                m3 := mload(0x60)
    12295
                m4 := mload(0x80)
    12296
                m5 := mload(0xa0)
    12297
                m6 := mload(0xc0)
    12298
                // Selector of `log(string,uint256,address,address)`.
    12299
                mstore(0x00, 0x5ea2b7ae)
    12300
                mstore(0x20, 0x80)
    12301
                mstore(0x40, p1)
    12302
                mstore(0x60, p2)
    12303
                mstore(0x80, p3)
    12304
                writeString(0xa0, p0)
    12305
            }
    12306
            _sendLogPayload(0x1c, 0xc4);
    12307
            /// @solidity memory-safe-assembly
    12308
            assembly {
    12309
                mstore(0x00, m0)
    12310
                mstore(0x20, m1)
    12311
                mstore(0x40, m2)
    12312
                mstore(0x60, m3)
    12313
                mstore(0x80, m4)
    12314
                mstore(0xa0, m5)
    12315
                mstore(0xc0, m6)
    12316
            }
    12317
        }
    12318
    12319
        function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {
    12320
            bytes32 m0;
    12321
            bytes32 m1;
    12322
            bytes32 m2;
    12323
            bytes32 m3;
    12324
            bytes32 m4;
    12325
            bytes32 m5;
    12326
            bytes32 m6;
    12327
            /// @solidity memory-safe-assembly
    12328
            assembly {
    12329
                function writeString(pos, w) {
    12330
                    let length := 0
    12331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12332
                    mstore(pos, length)
    12333
                    let shift := sub(256, shl(3, length))
    12334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12335
                }
    12336
                m0 := mload(0x00)
    12337
                m1 := mload(0x20)
    12338
                m2 := mload(0x40)
    12339
                m3 := mload(0x60)
    12340
                m4 := mload(0x80)
    12341
                m5 := mload(0xa0)
    12342
                m6 := mload(0xc0)
    12343
                // Selector of `log(string,uint256,address,bool)`.
    12344
                mstore(0x00, 0x82112a42)
    12345
                mstore(0x20, 0x80)
    12346
                mstore(0x40, p1)
    12347
                mstore(0x60, p2)
    12348
                mstore(0x80, p3)
    12349
                writeString(0xa0, p0)
    12350
            }
    12351
            _sendLogPayload(0x1c, 0xc4);
    12352
            /// @solidity memory-safe-assembly
    12353
            assembly {
    12354
                mstore(0x00, m0)
    12355
                mstore(0x20, m1)
    12356
                mstore(0x40, m2)
    12357
                mstore(0x60, m3)
    12358
                mstore(0x80, m4)
    12359
                mstore(0xa0, m5)
    12360
                mstore(0xc0, m6)
    12361
            }
    12362
        }
    12363
    12364
        function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {
    12365
            bytes32 m0;
    12366
            bytes32 m1;
    12367
            bytes32 m2;
    12368
            bytes32 m3;
    12369
            bytes32 m4;
    12370
            bytes32 m5;
    12371
            bytes32 m6;
    12372
            /// @solidity memory-safe-assembly
    12373
            assembly {
    12374
                function writeString(pos, w) {
    12375
                    let length := 0
    12376
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12377
                    mstore(pos, length)
    12378
                    let shift := sub(256, shl(3, length))
    12379
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12380
                }
    12381
                m0 := mload(0x00)
    12382
                m1 := mload(0x20)
    12383
                m2 := mload(0x40)
    12384
                m3 := mload(0x60)
    12385
                m4 := mload(0x80)
    12386
                m5 := mload(0xa0)
    12387
                m6 := mload(0xc0)
    12388
                // Selector of `log(string,uint256,address,uint256)`.
    12389
                mstore(0x00, 0x4f04fdc6)
    12390
                mstore(0x20, 0x80)
    12391
                mstore(0x40, p1)
    12392
                mstore(0x60, p2)
    12393
                mstore(0x80, p3)
    12394
                writeString(0xa0, p0)
    12395
            }
    12396
            _sendLogPayload(0x1c, 0xc4);
    12397
            /// @solidity memory-safe-assembly
    12398
            assembly {
    12399
                mstore(0x00, m0)
    12400
                mstore(0x20, m1)
    12401
                mstore(0x40, m2)
    12402
                mstore(0x60, m3)
    12403
                mstore(0x80, m4)
    12404
                mstore(0xa0, m5)
    12405
                mstore(0xc0, m6)
    12406
            }
    12407
        }
    12408
    12409
        function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {
    12410
            bytes32 m0;
    12411
            bytes32 m1;
    12412
            bytes32 m2;
    12413
            bytes32 m3;
    12414
            bytes32 m4;
    12415
            bytes32 m5;
    12416
            bytes32 m6;
    12417
            bytes32 m7;
    12418
            bytes32 m8;
    12419
            /// @solidity memory-safe-assembly
    12420
            assembly {
    12421
                function writeString(pos, w) {
    12422
                    let length := 0
    12423
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12424
                    mstore(pos, length)
    12425
                    let shift := sub(256, shl(3, length))
    12426
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12427
                }
    12428
                m0 := mload(0x00)
    12429
                m1 := mload(0x20)
    12430
                m2 := mload(0x40)
    12431
                m3 := mload(0x60)
    12432
                m4 := mload(0x80)
    12433
                m5 := mload(0xa0)
    12434
                m6 := mload(0xc0)
    12435
                m7 := mload(0xe0)
    12436
                m8 := mload(0x100)
    12437
                // Selector of `log(string,uint256,address,string)`.
    12438
                mstore(0x00, 0x9ffb2f93)
    12439
                mstore(0x20, 0x80)
    12440
                mstore(0x40, p1)
    12441
                mstore(0x60, p2)
    12442
                mstore(0x80, 0xc0)
    12443
                writeString(0xa0, p0)
    12444
                writeString(0xe0, p3)
    12445
            }
    12446
            _sendLogPayload(0x1c, 0x104);
    12447
            /// @solidity memory-safe-assembly
    12448
            assembly {
    12449
                mstore(0x00, m0)
    12450
                mstore(0x20, m1)
    12451
                mstore(0x40, m2)
    12452
                mstore(0x60, m3)
    12453
                mstore(0x80, m4)
    12454
                mstore(0xa0, m5)
    12455
                mstore(0xc0, m6)
    12456
                mstore(0xe0, m7)
    12457
                mstore(0x100, m8)
    12458
            }
    12459
        }
    12460
    12461
        function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {
    12462
            bytes32 m0;
    12463
            bytes32 m1;
    12464
            bytes32 m2;
    12465
            bytes32 m3;
    12466
            bytes32 m4;
    12467
            bytes32 m5;
    12468
            bytes32 m6;
    12469
            /// @solidity memory-safe-assembly
    12470
            assembly {
    12471
                function writeString(pos, w) {
    12472
                    let length := 0
    12473
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12474
                    mstore(pos, length)
    12475
                    let shift := sub(256, shl(3, length))
    12476
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12477
                }
    12478
                m0 := mload(0x00)
    12479
                m1 := mload(0x20)
    12480
                m2 := mload(0x40)
    12481
                m3 := mload(0x60)
    12482
                m4 := mload(0x80)
    12483
                m5 := mload(0xa0)
    12484
                m6 := mload(0xc0)
    12485
                // Selector of `log(string,uint256,bool,address)`.
    12486
                mstore(0x00, 0xe0e95b98)
    12487
                mstore(0x20, 0x80)
    12488
                mstore(0x40, p1)
    12489
                mstore(0x60, p2)
    12490
                mstore(0x80, p3)
    12491
                writeString(0xa0, p0)
    12492
            }
    12493
            _sendLogPayload(0x1c, 0xc4);
    12494
            /// @solidity memory-safe-assembly
    12495
            assembly {
    12496
                mstore(0x00, m0)
    12497
                mstore(0x20, m1)
    12498
                mstore(0x40, m2)
    12499
                mstore(0x60, m3)
    12500
                mstore(0x80, m4)
    12501
                mstore(0xa0, m5)
    12502
                mstore(0xc0, m6)
    12503
            }
    12504
        }
    12505
    12506
        function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {
    12507
            bytes32 m0;
    12508
            bytes32 m1;
    12509
            bytes32 m2;
    12510
            bytes32 m3;
    12511
            bytes32 m4;
    12512
            bytes32 m5;
    12513
            bytes32 m6;
    12514
            /// @solidity memory-safe-assembly
    12515
            assembly {
    12516
                function writeString(pos, w) {
    12517
                    let length := 0
    12518
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12519
                    mstore(pos, length)
    12520
                    let shift := sub(256, shl(3, length))
    12521
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12522
                }
    12523
                m0 := mload(0x00)
    12524
                m1 := mload(0x20)
    12525
                m2 := mload(0x40)
    12526
                m3 := mload(0x60)
    12527
                m4 := mload(0x80)
    12528
                m5 := mload(0xa0)
    12529
                m6 := mload(0xc0)
    12530
                // Selector of `log(string,uint256,bool,bool)`.
    12531
                mstore(0x00, 0x354c36d6)
    12532
                mstore(0x20, 0x80)
    12533
                mstore(0x40, p1)
    12534
                mstore(0x60, p2)
    12535
                mstore(0x80, p3)
    12536
                writeString(0xa0, p0)
    12537
            }
    12538
            _sendLogPayload(0x1c, 0xc4);
    12539
            /// @solidity memory-safe-assembly
    12540
            assembly {
    12541
                mstore(0x00, m0)
    12542
                mstore(0x20, m1)
    12543
                mstore(0x40, m2)
    12544
                mstore(0x60, m3)
    12545
                mstore(0x80, m4)
    12546
                mstore(0xa0, m5)
    12547
                mstore(0xc0, m6)
    12548
            }
    12549
        }
    12550
    12551
        function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {
    12552
            bytes32 m0;
    12553
            bytes32 m1;
    12554
            bytes32 m2;
    12555
            bytes32 m3;
    12556
            bytes32 m4;
    12557
            bytes32 m5;
    12558
            bytes32 m6;
    12559
            /// @solidity memory-safe-assembly
    12560
            assembly {
    12561
                function writeString(pos, w) {
    12562
                    let length := 0
    12563
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12564
                    mstore(pos, length)
    12565
                    let shift := sub(256, shl(3, length))
    12566
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12567
                }
    12568
                m0 := mload(0x00)
    12569
                m1 := mload(0x20)
    12570
                m2 := mload(0x40)
    12571
                m3 := mload(0x60)
    12572
                m4 := mload(0x80)
    12573
                m5 := mload(0xa0)
    12574
                m6 := mload(0xc0)
    12575
                // Selector of `log(string,uint256,bool,uint256)`.
    12576
                mstore(0x00, 0xe41b6f6f)
    12577
                mstore(0x20, 0x80)
    12578
                mstore(0x40, p1)
    12579
                mstore(0x60, p2)
    12580
                mstore(0x80, p3)
    12581
                writeString(0xa0, p0)
    12582
            }
    12583
            _sendLogPayload(0x1c, 0xc4);
    12584
            /// @solidity memory-safe-assembly
    12585
            assembly {
    12586
                mstore(0x00, m0)
    12587
                mstore(0x20, m1)
    12588
                mstore(0x40, m2)
    12589
                mstore(0x60, m3)
    12590
                mstore(0x80, m4)
    12591
                mstore(0xa0, m5)
    12592
                mstore(0xc0, m6)
    12593
            }
    12594
        }
    12595
    12596
        function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
    12597
            bytes32 m0;
    12598
            bytes32 m1;
    12599
            bytes32 m2;
    12600
            bytes32 m3;
    12601
            bytes32 m4;
    12602
            bytes32 m5;
    12603
            bytes32 m6;
    12604
            bytes32 m7;
    12605
            bytes32 m8;
    12606
            /// @solidity memory-safe-assembly
    12607
            assembly {
    12608
                function writeString(pos, w) {
    12609
                    let length := 0
    12610
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12611
                    mstore(pos, length)
    12612
                    let shift := sub(256, shl(3, length))
    12613
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12614
                }
    12615
                m0 := mload(0x00)
    12616
                m1 := mload(0x20)
    12617
                m2 := mload(0x40)
    12618
                m3 := mload(0x60)
    12619
                m4 := mload(0x80)
    12620
                m5 := mload(0xa0)
    12621
                m6 := mload(0xc0)
    12622
                m7 := mload(0xe0)
    12623
                m8 := mload(0x100)
    12624
                // Selector of `log(string,uint256,bool,string)`.
    12625
                mstore(0x00, 0xabf73a98)
    12626
                mstore(0x20, 0x80)
    12627
                mstore(0x40, p1)
    12628
                mstore(0x60, p2)
    12629
                mstore(0x80, 0xc0)
    12630
                writeString(0xa0, p0)
    12631
                writeString(0xe0, p3)
    12632
            }
    12633
            _sendLogPayload(0x1c, 0x104);
    12634
            /// @solidity memory-safe-assembly
    12635
            assembly {
    12636
                mstore(0x00, m0)
    12637
                mstore(0x20, m1)
    12638
                mstore(0x40, m2)
    12639
                mstore(0x60, m3)
    12640
                mstore(0x80, m4)
    12641
                mstore(0xa0, m5)
    12642
                mstore(0xc0, m6)
    12643
                mstore(0xe0, m7)
    12644
                mstore(0x100, m8)
    12645
            }
    12646
        }
    12647
    12648
        function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {
    12649
            bytes32 m0;
    12650
            bytes32 m1;
    12651
            bytes32 m2;
    12652
            bytes32 m3;
    12653
            bytes32 m4;
    12654
            bytes32 m5;
    12655
            bytes32 m6;
    12656
            /// @solidity memory-safe-assembly
    12657
            assembly {
    12658
                function writeString(pos, w) {
    12659
                    let length := 0
    12660
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12661
                    mstore(pos, length)
    12662
                    let shift := sub(256, shl(3, length))
    12663
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12664
                }
    12665
                m0 := mload(0x00)
    12666
                m1 := mload(0x20)
    12667
                m2 := mload(0x40)
    12668
                m3 := mload(0x60)
    12669
                m4 := mload(0x80)
    12670
                m5 := mload(0xa0)
    12671
                m6 := mload(0xc0)
    12672
                // Selector of `log(string,uint256,uint256,address)`.
    12673
                mstore(0x00, 0xe21de278)
    12674
                mstore(0x20, 0x80)
    12675
                mstore(0x40, p1)
    12676
                mstore(0x60, p2)
    12677
                mstore(0x80, p3)
    12678
                writeString(0xa0, p0)
    12679
            }
    12680
            _sendLogPayload(0x1c, 0xc4);
    12681
            /// @solidity memory-safe-assembly
    12682
            assembly {
    12683
                mstore(0x00, m0)
    12684
                mstore(0x20, m1)
    12685
                mstore(0x40, m2)
    12686
                mstore(0x60, m3)
    12687
                mstore(0x80, m4)
    12688
                mstore(0xa0, m5)
    12689
                mstore(0xc0, m6)
    12690
            }
    12691
        }
    12692
    12693
        function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {
    12694
            bytes32 m0;
    12695
            bytes32 m1;
    12696
            bytes32 m2;
    12697
            bytes32 m3;
    12698
            bytes32 m4;
    12699
            bytes32 m5;
    12700
            bytes32 m6;
    12701
            /// @solidity memory-safe-assembly
    12702
            assembly {
    12703
                function writeString(pos, w) {
    12704
                    let length := 0
    12705
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12706
                    mstore(pos, length)
    12707
                    let shift := sub(256, shl(3, length))
    12708
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12709
                }
    12710
                m0 := mload(0x00)
    12711
                m1 := mload(0x20)
    12712
                m2 := mload(0x40)
    12713
                m3 := mload(0x60)
    12714
                m4 := mload(0x80)
    12715
                m5 := mload(0xa0)
    12716
                m6 := mload(0xc0)
    12717
                // Selector of `log(string,uint256,uint256,bool)`.
    12718
                mstore(0x00, 0x7626db92)
    12719
                mstore(0x20, 0x80)
    12720
                mstore(0x40, p1)
    12721
                mstore(0x60, p2)
    12722
                mstore(0x80, p3)
    12723
                writeString(0xa0, p0)
    12724
            }
    12725
            _sendLogPayload(0x1c, 0xc4);
    12726
            /// @solidity memory-safe-assembly
    12727
            assembly {
    12728
                mstore(0x00, m0)
    12729
                mstore(0x20, m1)
    12730
                mstore(0x40, m2)
    12731
                mstore(0x60, m3)
    12732
                mstore(0x80, m4)
    12733
                mstore(0xa0, m5)
    12734
                mstore(0xc0, m6)
    12735
            }
    12736
        }
    12737
    12738
        function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
    12739
            bytes32 m0;
    12740
            bytes32 m1;
    12741
            bytes32 m2;
    12742
            bytes32 m3;
    12743
            bytes32 m4;
    12744
            bytes32 m5;
    12745
            bytes32 m6;
    12746
            /// @solidity memory-safe-assembly
    12747
            assembly {
    12748
                function writeString(pos, w) {
    12749
                    let length := 0
    12750
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12751
                    mstore(pos, length)
    12752
                    let shift := sub(256, shl(3, length))
    12753
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12754
                }
    12755
                m0 := mload(0x00)
    12756
                m1 := mload(0x20)
    12757
                m2 := mload(0x40)
    12758
                m3 := mload(0x60)
    12759
                m4 := mload(0x80)
    12760
                m5 := mload(0xa0)
    12761
                m6 := mload(0xc0)
    12762
                // Selector of `log(string,uint256,uint256,uint256)`.
    12763
                mstore(0x00, 0xa7a87853)
    12764
                mstore(0x20, 0x80)
    12765
                mstore(0x40, p1)
    12766
                mstore(0x60, p2)
    12767
                mstore(0x80, p3)
    12768
                writeString(0xa0, p0)
    12769
            }
    12770
            _sendLogPayload(0x1c, 0xc4);
    12771
            /// @solidity memory-safe-assembly
    12772
            assembly {
    12773
                mstore(0x00, m0)
    12774
                mstore(0x20, m1)
    12775
                mstore(0x40, m2)
    12776
                mstore(0x60, m3)
    12777
                mstore(0x80, m4)
    12778
                mstore(0xa0, m5)
    12779
                mstore(0xc0, m6)
    12780
            }
    12781
        }
    12782
    12783
        function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
    12784
            bytes32 m0;
    12785
            bytes32 m1;
    12786
            bytes32 m2;
    12787
            bytes32 m3;
    12788
            bytes32 m4;
    12789
            bytes32 m5;
    12790
            bytes32 m6;
    12791
            bytes32 m7;
    12792
            bytes32 m8;
    12793
            /// @solidity memory-safe-assembly
    12794
            assembly {
    12795
                function writeString(pos, w) {
    12796
                    let length := 0
    12797
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12798
                    mstore(pos, length)
    12799
                    let shift := sub(256, shl(3, length))
    12800
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12801
                }
    12802
                m0 := mload(0x00)
    12803
                m1 := mload(0x20)
    12804
                m2 := mload(0x40)
    12805
                m3 := mload(0x60)
    12806
                m4 := mload(0x80)
    12807
                m5 := mload(0xa0)
    12808
                m6 := mload(0xc0)
    12809
                m7 := mload(0xe0)
    12810
                m8 := mload(0x100)
    12811
                // Selector of `log(string,uint256,uint256,string)`.
    12812
                mstore(0x00, 0x854b3496)
    12813
                mstore(0x20, 0x80)
    12814
                mstore(0x40, p1)
    12815
                mstore(0x60, p2)
    12816
                mstore(0x80, 0xc0)
    12817
                writeString(0xa0, p0)
    12818
                writeString(0xe0, p3)
    12819
            }
    12820
            _sendLogPayload(0x1c, 0x104);
    12821
            /// @solidity memory-safe-assembly
    12822
            assembly {
    12823
                mstore(0x00, m0)
    12824
                mstore(0x20, m1)
    12825
                mstore(0x40, m2)
    12826
                mstore(0x60, m3)
    12827
                mstore(0x80, m4)
    12828
                mstore(0xa0, m5)
    12829
                mstore(0xc0, m6)
    12830
                mstore(0xe0, m7)
    12831
                mstore(0x100, m8)
    12832
            }
    12833
        }
    12834
    12835
        function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {
    12836
            bytes32 m0;
    12837
            bytes32 m1;
    12838
            bytes32 m2;
    12839
            bytes32 m3;
    12840
            bytes32 m4;
    12841
            bytes32 m5;
    12842
            bytes32 m6;
    12843
            bytes32 m7;
    12844
            bytes32 m8;
    12845
            /// @solidity memory-safe-assembly
    12846
            assembly {
    12847
                function writeString(pos, w) {
    12848
                    let length := 0
    12849
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12850
                    mstore(pos, length)
    12851
                    let shift := sub(256, shl(3, length))
    12852
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12853
                }
    12854
                m0 := mload(0x00)
    12855
                m1 := mload(0x20)
    12856
                m2 := mload(0x40)
    12857
                m3 := mload(0x60)
    12858
                m4 := mload(0x80)
    12859
                m5 := mload(0xa0)
    12860
                m6 := mload(0xc0)
    12861
                m7 := mload(0xe0)
    12862
                m8 := mload(0x100)
    12863
                // Selector of `log(string,uint256,string,address)`.
    12864
                mstore(0x00, 0x7c4632a4)
    12865
                mstore(0x20, 0x80)
    12866
                mstore(0x40, p1)
    12867
                mstore(0x60, 0xc0)
    12868
                mstore(0x80, p3)
    12869
                writeString(0xa0, p0)
    12870
                writeString(0xe0, p2)
    12871
            }
    12872
            _sendLogPayload(0x1c, 0x104);
    12873
            /// @solidity memory-safe-assembly
    12874
            assembly {
    12875
                mstore(0x00, m0)
    12876
                mstore(0x20, m1)
    12877
                mstore(0x40, m2)
    12878
                mstore(0x60, m3)
    12879
                mstore(0x80, m4)
    12880
                mstore(0xa0, m5)
    12881
                mstore(0xc0, m6)
    12882
                mstore(0xe0, m7)
    12883
                mstore(0x100, m8)
    12884
            }
    12885
        }
    12886
    12887
        function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
    12888
            bytes32 m0;
    12889
            bytes32 m1;
    12890
            bytes32 m2;
    12891
            bytes32 m3;
    12892
            bytes32 m4;
    12893
            bytes32 m5;
    12894
            bytes32 m6;
    12895
            bytes32 m7;
    12896
            bytes32 m8;
    12897
            /// @solidity memory-safe-assembly
    12898
            assembly {
    12899
                function writeString(pos, w) {
    12900
                    let length := 0
    12901
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12902
                    mstore(pos, length)
    12903
                    let shift := sub(256, shl(3, length))
    12904
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12905
                }
    12906
                m0 := mload(0x00)
    12907
                m1 := mload(0x20)
    12908
                m2 := mload(0x40)
    12909
                m3 := mload(0x60)
    12910
                m4 := mload(0x80)
    12911
                m5 := mload(0xa0)
    12912
                m6 := mload(0xc0)
    12913
                m7 := mload(0xe0)
    12914
                m8 := mload(0x100)
    12915
                // Selector of `log(string,uint256,string,bool)`.
    12916
                mstore(0x00, 0x7d24491d)
    12917
                mstore(0x20, 0x80)
    12918
                mstore(0x40, p1)
    12919
                mstore(0x60, 0xc0)
    12920
                mstore(0x80, p3)
    12921
                writeString(0xa0, p0)
    12922
                writeString(0xe0, p2)
    12923
            }
    12924
            _sendLogPayload(0x1c, 0x104);
    12925
            /// @solidity memory-safe-assembly
    12926
            assembly {
    12927
                mstore(0x00, m0)
    12928
                mstore(0x20, m1)
    12929
                mstore(0x40, m2)
    12930
                mstore(0x60, m3)
    12931
                mstore(0x80, m4)
    12932
                mstore(0xa0, m5)
    12933
                mstore(0xc0, m6)
    12934
                mstore(0xe0, m7)
    12935
                mstore(0x100, m8)
    12936
            }
    12937
        }
    12938
    12939
        function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
    12940
            bytes32 m0;
    12941
            bytes32 m1;
    12942
            bytes32 m2;
    12943
            bytes32 m3;
    12944
            bytes32 m4;
    12945
            bytes32 m5;
    12946
            bytes32 m6;
    12947
            bytes32 m7;
    12948
            bytes32 m8;
    12949
            /// @solidity memory-safe-assembly
    12950
            assembly {
    12951
                function writeString(pos, w) {
    12952
                    let length := 0
    12953
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    12954
                    mstore(pos, length)
    12955
                    let shift := sub(256, shl(3, length))
    12956
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    12957
                }
    12958
                m0 := mload(0x00)
    12959
                m1 := mload(0x20)
    12960
                m2 := mload(0x40)
    12961
                m3 := mload(0x60)
    12962
                m4 := mload(0x80)
    12963
                m5 := mload(0xa0)
    12964
                m6 := mload(0xc0)
    12965
                m7 := mload(0xe0)
    12966
                m8 := mload(0x100)
    12967
                // Selector of `log(string,uint256,string,uint256)`.
    12968
                mstore(0x00, 0xc67ea9d1)
    12969
                mstore(0x20, 0x80)
    12970
                mstore(0x40, p1)
    12971
                mstore(0x60, 0xc0)
    12972
                mstore(0x80, p3)
    12973
                writeString(0xa0, p0)
    12974
                writeString(0xe0, p2)
    12975
            }
    12976
            _sendLogPayload(0x1c, 0x104);
    12977
            /// @solidity memory-safe-assembly
    12978
            assembly {
    12979
                mstore(0x00, m0)
    12980
                mstore(0x20, m1)
    12981
                mstore(0x40, m2)
    12982
                mstore(0x60, m3)
    12983
                mstore(0x80, m4)
    12984
                mstore(0xa0, m5)
    12985
                mstore(0xc0, m6)
    12986
                mstore(0xe0, m7)
    12987
                mstore(0x100, m8)
    12988
            }
    12989
        }
    12990
    12991
        function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
    12992
            bytes32 m0;
    12993
            bytes32 m1;
    12994
            bytes32 m2;
    12995
            bytes32 m3;
    12996
            bytes32 m4;
    12997
            bytes32 m5;
    12998
            bytes32 m6;
    12999
            bytes32 m7;
    13000
            bytes32 m8;
    13001
            bytes32 m9;
    13002
            bytes32 m10;
    13003
            /// @solidity memory-safe-assembly
    13004
            assembly {
    13005
                function writeString(pos, w) {
    13006
                    let length := 0
    13007
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13008
                    mstore(pos, length)
    13009
                    let shift := sub(256, shl(3, length))
    13010
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13011
                }
    13012
                m0 := mload(0x00)
    13013
                m1 := mload(0x20)
    13014
                m2 := mload(0x40)
    13015
                m3 := mload(0x60)
    13016
                m4 := mload(0x80)
    13017
                m5 := mload(0xa0)
    13018
                m6 := mload(0xc0)
    13019
                m7 := mload(0xe0)
    13020
                m8 := mload(0x100)
    13021
                m9 := mload(0x120)
    13022
                m10 := mload(0x140)
    13023
                // Selector of `log(string,uint256,string,string)`.
    13024
                mstore(0x00, 0x5ab84e1f)
    13025
                mstore(0x20, 0x80)
    13026
                mstore(0x40, p1)
    13027
                mstore(0x60, 0xc0)
    13028
                mstore(0x80, 0x100)
    13029
                writeString(0xa0, p0)
    13030
                writeString(0xe0, p2)
    13031
                writeString(0x120, p3)
    13032
            }
    13033
            _sendLogPayload(0x1c, 0x144);
    13034
            /// @solidity memory-safe-assembly
    13035
            assembly {
    13036
                mstore(0x00, m0)
    13037
                mstore(0x20, m1)
    13038
                mstore(0x40, m2)
    13039
                mstore(0x60, m3)
    13040
                mstore(0x80, m4)
    13041
                mstore(0xa0, m5)
    13042
                mstore(0xc0, m6)
    13043
                mstore(0xe0, m7)
    13044
                mstore(0x100, m8)
    13045
                mstore(0x120, m9)
    13046
                mstore(0x140, m10)
    13047
            }
    13048
        }
    13049
    13050
        function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {
    13051
            bytes32 m0;
    13052
            bytes32 m1;
    13053
            bytes32 m2;
    13054
            bytes32 m3;
    13055
            bytes32 m4;
    13056
            bytes32 m5;
    13057
            bytes32 m6;
    13058
            bytes32 m7;
    13059
            bytes32 m8;
    13060
            /// @solidity memory-safe-assembly
    13061
            assembly {
    13062
                function writeString(pos, w) {
    13063
                    let length := 0
    13064
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13065
                    mstore(pos, length)
    13066
                    let shift := sub(256, shl(3, length))
    13067
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13068
                }
    13069
                m0 := mload(0x00)
    13070
                m1 := mload(0x20)
    13071
                m2 := mload(0x40)
    13072
                m3 := mload(0x60)
    13073
                m4 := mload(0x80)
    13074
                m5 := mload(0xa0)
    13075
                m6 := mload(0xc0)
    13076
                m7 := mload(0xe0)
    13077
                m8 := mload(0x100)
    13078
                // Selector of `log(string,string,address,address)`.
    13079
                mstore(0x00, 0x439c7bef)
    13080
                mstore(0x20, 0x80)
    13081
                mstore(0x40, 0xc0)
    13082
                mstore(0x60, p2)
    13083
                mstore(0x80, p3)
    13084
                writeString(0xa0, p0)
    13085
                writeString(0xe0, p1)
    13086
            }
    13087
            _sendLogPayload(0x1c, 0x104);
    13088
            /// @solidity memory-safe-assembly
    13089
            assembly {
    13090
                mstore(0x00, m0)
    13091
                mstore(0x20, m1)
    13092
                mstore(0x40, m2)
    13093
                mstore(0x60, m3)
    13094
                mstore(0x80, m4)
    13095
                mstore(0xa0, m5)
    13096
                mstore(0xc0, m6)
    13097
                mstore(0xe0, m7)
    13098
                mstore(0x100, m8)
    13099
            }
    13100
        }
    13101
    13102
        function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {
    13103
            bytes32 m0;
    13104
            bytes32 m1;
    13105
            bytes32 m2;
    13106
            bytes32 m3;
    13107
            bytes32 m4;
    13108
            bytes32 m5;
    13109
            bytes32 m6;
    13110
            bytes32 m7;
    13111
            bytes32 m8;
    13112
            /// @solidity memory-safe-assembly
    13113
            assembly {
    13114
                function writeString(pos, w) {
    13115
                    let length := 0
    13116
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13117
                    mstore(pos, length)
    13118
                    let shift := sub(256, shl(3, length))
    13119
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13120
                }
    13121
                m0 := mload(0x00)
    13122
                m1 := mload(0x20)
    13123
                m2 := mload(0x40)
    13124
                m3 := mload(0x60)
    13125
                m4 := mload(0x80)
    13126
                m5 := mload(0xa0)
    13127
                m6 := mload(0xc0)
    13128
                m7 := mload(0xe0)
    13129
                m8 := mload(0x100)
    13130
                // Selector of `log(string,string,address,bool)`.
    13131
                mstore(0x00, 0x5ccd4e37)
    13132
                mstore(0x20, 0x80)
    13133
                mstore(0x40, 0xc0)
    13134
                mstore(0x60, p2)
    13135
                mstore(0x80, p3)
    13136
                writeString(0xa0, p0)
    13137
                writeString(0xe0, p1)
    13138
            }
    13139
            _sendLogPayload(0x1c, 0x104);
    13140
            /// @solidity memory-safe-assembly
    13141
            assembly {
    13142
                mstore(0x00, m0)
    13143
                mstore(0x20, m1)
    13144
                mstore(0x40, m2)
    13145
                mstore(0x60, m3)
    13146
                mstore(0x80, m4)
    13147
                mstore(0xa0, m5)
    13148
                mstore(0xc0, m6)
    13149
                mstore(0xe0, m7)
    13150
                mstore(0x100, m8)
    13151
            }
    13152
        }
    13153
    13154
        function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {
    13155
            bytes32 m0;
    13156
            bytes32 m1;
    13157
            bytes32 m2;
    13158
            bytes32 m3;
    13159
            bytes32 m4;
    13160
            bytes32 m5;
    13161
            bytes32 m6;
    13162
            bytes32 m7;
    13163
            bytes32 m8;
    13164
            /// @solidity memory-safe-assembly
    13165
            assembly {
    13166
                function writeString(pos, w) {
    13167
                    let length := 0
    13168
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13169
                    mstore(pos, length)
    13170
                    let shift := sub(256, shl(3, length))
    13171
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13172
                }
    13173
                m0 := mload(0x00)
    13174
                m1 := mload(0x20)
    13175
                m2 := mload(0x40)
    13176
                m3 := mload(0x60)
    13177
                m4 := mload(0x80)
    13178
                m5 := mload(0xa0)
    13179
                m6 := mload(0xc0)
    13180
                m7 := mload(0xe0)
    13181
                m8 := mload(0x100)
    13182
                // Selector of `log(string,string,address,uint256)`.
    13183
                mstore(0x00, 0x7cc3c607)
    13184
                mstore(0x20, 0x80)
    13185
                mstore(0x40, 0xc0)
    13186
                mstore(0x60, p2)
    13187
                mstore(0x80, p3)
    13188
                writeString(0xa0, p0)
    13189
                writeString(0xe0, p1)
    13190
            }
    13191
            _sendLogPayload(0x1c, 0x104);
    13192
            /// @solidity memory-safe-assembly
    13193
            assembly {
    13194
                mstore(0x00, m0)
    13195
                mstore(0x20, m1)
    13196
                mstore(0x40, m2)
    13197
                mstore(0x60, m3)
    13198
                mstore(0x80, m4)
    13199
                mstore(0xa0, m5)
    13200
                mstore(0xc0, m6)
    13201
                mstore(0xe0, m7)
    13202
                mstore(0x100, m8)
    13203
            }
    13204
        }
    13205
    13206
        function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
    13207
            bytes32 m0;
    13208
            bytes32 m1;
    13209
            bytes32 m2;
    13210
            bytes32 m3;
    13211
            bytes32 m4;
    13212
            bytes32 m5;
    13213
            bytes32 m6;
    13214
            bytes32 m7;
    13215
            bytes32 m8;
    13216
            bytes32 m9;
    13217
            bytes32 m10;
    13218
            /// @solidity memory-safe-assembly
    13219
            assembly {
    13220
                function writeString(pos, w) {
    13221
                    let length := 0
    13222
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13223
                    mstore(pos, length)
    13224
                    let shift := sub(256, shl(3, length))
    13225
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13226
                }
    13227
                m0 := mload(0x00)
    13228
                m1 := mload(0x20)
    13229
                m2 := mload(0x40)
    13230
                m3 := mload(0x60)
    13231
                m4 := mload(0x80)
    13232
                m5 := mload(0xa0)
    13233
                m6 := mload(0xc0)
    13234
                m7 := mload(0xe0)
    13235
                m8 := mload(0x100)
    13236
                m9 := mload(0x120)
    13237
                m10 := mload(0x140)
    13238
                // Selector of `log(string,string,address,string)`.
    13239
                mstore(0x00, 0xeb1bff80)
    13240
                mstore(0x20, 0x80)
    13241
                mstore(0x40, 0xc0)
    13242
                mstore(0x60, p2)
    13243
                mstore(0x80, 0x100)
    13244
                writeString(0xa0, p0)
    13245
                writeString(0xe0, p1)
    13246
                writeString(0x120, p3)
    13247
            }
    13248
            _sendLogPayload(0x1c, 0x144);
    13249
            /// @solidity memory-safe-assembly
    13250
            assembly {
    13251
                mstore(0x00, m0)
    13252
                mstore(0x20, m1)
    13253
                mstore(0x40, m2)
    13254
                mstore(0x60, m3)
    13255
                mstore(0x80, m4)
    13256
                mstore(0xa0, m5)
    13257
                mstore(0xc0, m6)
    13258
                mstore(0xe0, m7)
    13259
                mstore(0x100, m8)
    13260
                mstore(0x120, m9)
    13261
                mstore(0x140, m10)
    13262
            }
    13263
        }
    13264
    13265
        function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {
    13266
            bytes32 m0;
    13267
            bytes32 m1;
    13268
            bytes32 m2;
    13269
            bytes32 m3;
    13270
            bytes32 m4;
    13271
            bytes32 m5;
    13272
            bytes32 m6;
    13273
            bytes32 m7;
    13274
            bytes32 m8;
    13275
            /// @solidity memory-safe-assembly
    13276
            assembly {
    13277
                function writeString(pos, w) {
    13278
                    let length := 0
    13279
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13280
                    mstore(pos, length)
    13281
                    let shift := sub(256, shl(3, length))
    13282
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13283
                }
    13284
                m0 := mload(0x00)
    13285
                m1 := mload(0x20)
    13286
                m2 := mload(0x40)
    13287
                m3 := mload(0x60)
    13288
                m4 := mload(0x80)
    13289
                m5 := mload(0xa0)
    13290
                m6 := mload(0xc0)
    13291
                m7 := mload(0xe0)
    13292
                m8 := mload(0x100)
    13293
                // Selector of `log(string,string,bool,address)`.
    13294
                mstore(0x00, 0xc371c7db)
    13295
                mstore(0x20, 0x80)
    13296
                mstore(0x40, 0xc0)
    13297
                mstore(0x60, p2)
    13298
                mstore(0x80, p3)
    13299
                writeString(0xa0, p0)
    13300
                writeString(0xe0, p1)
    13301
            }
    13302
            _sendLogPayload(0x1c, 0x104);
    13303
            /// @solidity memory-safe-assembly
    13304
            assembly {
    13305
                mstore(0x00, m0)
    13306
                mstore(0x20, m1)
    13307
                mstore(0x40, m2)
    13308
                mstore(0x60, m3)
    13309
                mstore(0x80, m4)
    13310
                mstore(0xa0, m5)
    13311
                mstore(0xc0, m6)
    13312
                mstore(0xe0, m7)
    13313
                mstore(0x100, m8)
    13314
            }
    13315
        }
    13316
    13317
        function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {
    13318
            bytes32 m0;
    13319
            bytes32 m1;
    13320
            bytes32 m2;
    13321
            bytes32 m3;
    13322
            bytes32 m4;
    13323
            bytes32 m5;
    13324
            bytes32 m6;
    13325
            bytes32 m7;
    13326
            bytes32 m8;
    13327
            /// @solidity memory-safe-assembly
    13328
            assembly {
    13329
                function writeString(pos, w) {
    13330
                    let length := 0
    13331
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13332
                    mstore(pos, length)
    13333
                    let shift := sub(256, shl(3, length))
    13334
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13335
                }
    13336
                m0 := mload(0x00)
    13337
                m1 := mload(0x20)
    13338
                m2 := mload(0x40)
    13339
                m3 := mload(0x60)
    13340
                m4 := mload(0x80)
    13341
                m5 := mload(0xa0)
    13342
                m6 := mload(0xc0)
    13343
                m7 := mload(0xe0)
    13344
                m8 := mload(0x100)
    13345
                // Selector of `log(string,string,bool,bool)`.
    13346
                mstore(0x00, 0x40785869)
    13347
                mstore(0x20, 0x80)
    13348
                mstore(0x40, 0xc0)
    13349
                mstore(0x60, p2)
    13350
                mstore(0x80, p3)
    13351
                writeString(0xa0, p0)
    13352
                writeString(0xe0, p1)
    13353
            }
    13354
            _sendLogPayload(0x1c, 0x104);
    13355
            /// @solidity memory-safe-assembly
    13356
            assembly {
    13357
                mstore(0x00, m0)
    13358
                mstore(0x20, m1)
    13359
                mstore(0x40, m2)
    13360
                mstore(0x60, m3)
    13361
                mstore(0x80, m4)
    13362
                mstore(0xa0, m5)
    13363
                mstore(0xc0, m6)
    13364
                mstore(0xe0, m7)
    13365
                mstore(0x100, m8)
    13366
            }
    13367
        }
    13368
    13369
        function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
    13370
            bytes32 m0;
    13371
            bytes32 m1;
    13372
            bytes32 m2;
    13373
            bytes32 m3;
    13374
            bytes32 m4;
    13375
            bytes32 m5;
    13376
            bytes32 m6;
    13377
            bytes32 m7;
    13378
            bytes32 m8;
    13379
            /// @solidity memory-safe-assembly
    13380
            assembly {
    13381
                function writeString(pos, w) {
    13382
                    let length := 0
    13383
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13384
                    mstore(pos, length)
    13385
                    let shift := sub(256, shl(3, length))
    13386
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13387
                }
    13388
                m0 := mload(0x00)
    13389
                m1 := mload(0x20)
    13390
                m2 := mload(0x40)
    13391
                m3 := mload(0x60)
    13392
                m4 := mload(0x80)
    13393
                m5 := mload(0xa0)
    13394
                m6 := mload(0xc0)
    13395
                m7 := mload(0xe0)
    13396
                m8 := mload(0x100)
    13397
                // Selector of `log(string,string,bool,uint256)`.
    13398
                mstore(0x00, 0xd6aefad2)
    13399
                mstore(0x20, 0x80)
    13400
                mstore(0x40, 0xc0)
    13401
                mstore(0x60, p2)
    13402
                mstore(0x80, p3)
    13403
                writeString(0xa0, p0)
    13404
                writeString(0xe0, p1)
    13405
            }
    13406
            _sendLogPayload(0x1c, 0x104);
    13407
            /// @solidity memory-safe-assembly
    13408
            assembly {
    13409
                mstore(0x00, m0)
    13410
                mstore(0x20, m1)
    13411
                mstore(0x40, m2)
    13412
                mstore(0x60, m3)
    13413
                mstore(0x80, m4)
    13414
                mstore(0xa0, m5)
    13415
                mstore(0xc0, m6)
    13416
                mstore(0xe0, m7)
    13417
                mstore(0x100, m8)
    13418
            }
    13419
        }
    13420
    13421
        function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
    13422
            bytes32 m0;
    13423
            bytes32 m1;
    13424
            bytes32 m2;
    13425
            bytes32 m3;
    13426
            bytes32 m4;
    13427
            bytes32 m5;
    13428
            bytes32 m6;
    13429
            bytes32 m7;
    13430
            bytes32 m8;
    13431
            bytes32 m9;
    13432
            bytes32 m10;
    13433
            /// @solidity memory-safe-assembly
    13434
            assembly {
    13435
                function writeString(pos, w) {
    13436
                    let length := 0
    13437
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13438
                    mstore(pos, length)
    13439
                    let shift := sub(256, shl(3, length))
    13440
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13441
                }
    13442
                m0 := mload(0x00)
    13443
                m1 := mload(0x20)
    13444
                m2 := mload(0x40)
    13445
                m3 := mload(0x60)
    13446
                m4 := mload(0x80)
    13447
                m5 := mload(0xa0)
    13448
                m6 := mload(0xc0)
    13449
                m7 := mload(0xe0)
    13450
                m8 := mload(0x100)
    13451
                m9 := mload(0x120)
    13452
                m10 := mload(0x140)
    13453
                // Selector of `log(string,string,bool,string)`.
    13454
                mstore(0x00, 0x5e84b0ea)
    13455
                mstore(0x20, 0x80)
    13456
                mstore(0x40, 0xc0)
    13457
                mstore(0x60, p2)
    13458
                mstore(0x80, 0x100)
    13459
                writeString(0xa0, p0)
    13460
                writeString(0xe0, p1)
    13461
                writeString(0x120, p3)
    13462
            }
    13463
            _sendLogPayload(0x1c, 0x144);
    13464
            /// @solidity memory-safe-assembly
    13465
            assembly {
    13466
                mstore(0x00, m0)
    13467
                mstore(0x20, m1)
    13468
                mstore(0x40, m2)
    13469
                mstore(0x60, m3)
    13470
                mstore(0x80, m4)
    13471
                mstore(0xa0, m5)
    13472
                mstore(0xc0, m6)
    13473
                mstore(0xe0, m7)
    13474
                mstore(0x100, m8)
    13475
                mstore(0x120, m9)
    13476
                mstore(0x140, m10)
    13477
            }
    13478
        }
    13479
    13480
        function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {
    13481
            bytes32 m0;
    13482
            bytes32 m1;
    13483
            bytes32 m2;
    13484
            bytes32 m3;
    13485
            bytes32 m4;
    13486
            bytes32 m5;
    13487
            bytes32 m6;
    13488
            bytes32 m7;
    13489
            bytes32 m8;
    13490
            /// @solidity memory-safe-assembly
    13491
            assembly {
    13492
                function writeString(pos, w) {
    13493
                    let length := 0
    13494
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13495
                    mstore(pos, length)
    13496
                    let shift := sub(256, shl(3, length))
    13497
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13498
                }
    13499
                m0 := mload(0x00)
    13500
                m1 := mload(0x20)
    13501
                m2 := mload(0x40)
    13502
                m3 := mload(0x60)
    13503
                m4 := mload(0x80)
    13504
                m5 := mload(0xa0)
    13505
                m6 := mload(0xc0)
    13506
                m7 := mload(0xe0)
    13507
                m8 := mload(0x100)
    13508
                // Selector of `log(string,string,uint256,address)`.
    13509
                mstore(0x00, 0x1023f7b2)
    13510
                mstore(0x20, 0x80)
    13511
                mstore(0x40, 0xc0)
    13512
                mstore(0x60, p2)
    13513
                mstore(0x80, p3)
    13514
                writeString(0xa0, p0)
    13515
                writeString(0xe0, p1)
    13516
            }
    13517
            _sendLogPayload(0x1c, 0x104);
    13518
            /// @solidity memory-safe-assembly
    13519
            assembly {
    13520
                mstore(0x00, m0)
    13521
                mstore(0x20, m1)
    13522
                mstore(0x40, m2)
    13523
                mstore(0x60, m3)
    13524
                mstore(0x80, m4)
    13525
                mstore(0xa0, m5)
    13526
                mstore(0xc0, m6)
    13527
                mstore(0xe0, m7)
    13528
                mstore(0x100, m8)
    13529
            }
    13530
        }
    13531
    13532
        function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
    13533
            bytes32 m0;
    13534
            bytes32 m1;
    13535
            bytes32 m2;
    13536
            bytes32 m3;
    13537
            bytes32 m4;
    13538
            bytes32 m5;
    13539
            bytes32 m6;
    13540
            bytes32 m7;
    13541
            bytes32 m8;
    13542
            /// @solidity memory-safe-assembly
    13543
            assembly {
    13544
                function writeString(pos, w) {
    13545
                    let length := 0
    13546
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13547
                    mstore(pos, length)
    13548
                    let shift := sub(256, shl(3, length))
    13549
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13550
                }
    13551
                m0 := mload(0x00)
    13552
                m1 := mload(0x20)
    13553
                m2 := mload(0x40)
    13554
                m3 := mload(0x60)
    13555
                m4 := mload(0x80)
    13556
                m5 := mload(0xa0)
    13557
                m6 := mload(0xc0)
    13558
                m7 := mload(0xe0)
    13559
                m8 := mload(0x100)
    13560
                // Selector of `log(string,string,uint256,bool)`.
    13561
                mstore(0x00, 0xc3a8a654)
    13562
                mstore(0x20, 0x80)
    13563
                mstore(0x40, 0xc0)
    13564
                mstore(0x60, p2)
    13565
                mstore(0x80, p3)
    13566
                writeString(0xa0, p0)
    13567
                writeString(0xe0, p1)
    13568
            }
    13569
            _sendLogPayload(0x1c, 0x104);
    13570
            /// @solidity memory-safe-assembly
    13571
            assembly {
    13572
                mstore(0x00, m0)
    13573
                mstore(0x20, m1)
    13574
                mstore(0x40, m2)
    13575
                mstore(0x60, m3)
    13576
                mstore(0x80, m4)
    13577
                mstore(0xa0, m5)
    13578
                mstore(0xc0, m6)
    13579
                mstore(0xe0, m7)
    13580
                mstore(0x100, m8)
    13581
            }
    13582
        }
    13583
    13584
        function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
    13585
            bytes32 m0;
    13586
            bytes32 m1;
    13587
            bytes32 m2;
    13588
            bytes32 m3;
    13589
            bytes32 m4;
    13590
            bytes32 m5;
    13591
            bytes32 m6;
    13592
            bytes32 m7;
    13593
            bytes32 m8;
    13594
            /// @solidity memory-safe-assembly
    13595
            assembly {
    13596
                function writeString(pos, w) {
    13597
                    let length := 0
    13598
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13599
                    mstore(pos, length)
    13600
                    let shift := sub(256, shl(3, length))
    13601
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13602
                }
    13603
                m0 := mload(0x00)
    13604
                m1 := mload(0x20)
    13605
                m2 := mload(0x40)
    13606
                m3 := mload(0x60)
    13607
                m4 := mload(0x80)
    13608
                m5 := mload(0xa0)
    13609
                m6 := mload(0xc0)
    13610
                m7 := mload(0xe0)
    13611
                m8 := mload(0x100)
    13612
                // Selector of `log(string,string,uint256,uint256)`.
    13613
                mstore(0x00, 0xf45d7d2c)
    13614
                mstore(0x20, 0x80)
    13615
                mstore(0x40, 0xc0)
    13616
                mstore(0x60, p2)
    13617
                mstore(0x80, p3)
    13618
                writeString(0xa0, p0)
    13619
                writeString(0xe0, p1)
    13620
            }
    13621
            _sendLogPayload(0x1c, 0x104);
    13622
            /// @solidity memory-safe-assembly
    13623
            assembly {
    13624
                mstore(0x00, m0)
    13625
                mstore(0x20, m1)
    13626
                mstore(0x40, m2)
    13627
                mstore(0x60, m3)
    13628
                mstore(0x80, m4)
    13629
                mstore(0xa0, m5)
    13630
                mstore(0xc0, m6)
    13631
                mstore(0xe0, m7)
    13632
                mstore(0x100, m8)
    13633
            }
    13634
        }
    13635
    13636
        function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
    13637
            bytes32 m0;
    13638
            bytes32 m1;
    13639
            bytes32 m2;
    13640
            bytes32 m3;
    13641
            bytes32 m4;
    13642
            bytes32 m5;
    13643
            bytes32 m6;
    13644
            bytes32 m7;
    13645
            bytes32 m8;
    13646
            bytes32 m9;
    13647
            bytes32 m10;
    13648
            /// @solidity memory-safe-assembly
    13649
            assembly {
    13650
                function writeString(pos, w) {
    13651
                    let length := 0
    13652
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13653
                    mstore(pos, length)
    13654
                    let shift := sub(256, shl(3, length))
    13655
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13656
                }
    13657
                m0 := mload(0x00)
    13658
                m1 := mload(0x20)
    13659
                m2 := mload(0x40)
    13660
                m3 := mload(0x60)
    13661
                m4 := mload(0x80)
    13662
                m5 := mload(0xa0)
    13663
                m6 := mload(0xc0)
    13664
                m7 := mload(0xe0)
    13665
                m8 := mload(0x100)
    13666
                m9 := mload(0x120)
    13667
                m10 := mload(0x140)
    13668
                // Selector of `log(string,string,uint256,string)`.
    13669
                mstore(0x00, 0x5d1a971a)
    13670
                mstore(0x20, 0x80)
    13671
                mstore(0x40, 0xc0)
    13672
                mstore(0x60, p2)
    13673
                mstore(0x80, 0x100)
    13674
                writeString(0xa0, p0)
    13675
                writeString(0xe0, p1)
    13676
                writeString(0x120, p3)
    13677
            }
    13678
            _sendLogPayload(0x1c, 0x144);
    13679
            /// @solidity memory-safe-assembly
    13680
            assembly {
    13681
                mstore(0x00, m0)
    13682
                mstore(0x20, m1)
    13683
                mstore(0x40, m2)
    13684
                mstore(0x60, m3)
    13685
                mstore(0x80, m4)
    13686
                mstore(0xa0, m5)
    13687
                mstore(0xc0, m6)
    13688
                mstore(0xe0, m7)
    13689
                mstore(0x100, m8)
    13690
                mstore(0x120, m9)
    13691
                mstore(0x140, m10)
    13692
            }
    13693
        }
    13694
    13695
        function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
    13696
            bytes32 m0;
    13697
            bytes32 m1;
    13698
            bytes32 m2;
    13699
            bytes32 m3;
    13700
            bytes32 m4;
    13701
            bytes32 m5;
    13702
            bytes32 m6;
    13703
            bytes32 m7;
    13704
            bytes32 m8;
    13705
            bytes32 m9;
    13706
            bytes32 m10;
    13707
            /// @solidity memory-safe-assembly
    13708
            assembly {
    13709
                function writeString(pos, w) {
    13710
                    let length := 0
    13711
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13712
                    mstore(pos, length)
    13713
                    let shift := sub(256, shl(3, length))
    13714
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13715
                }
    13716
                m0 := mload(0x00)
    13717
                m1 := mload(0x20)
    13718
                m2 := mload(0x40)
    13719
                m3 := mload(0x60)
    13720
                m4 := mload(0x80)
    13721
                m5 := mload(0xa0)
    13722
                m6 := mload(0xc0)
    13723
                m7 := mload(0xe0)
    13724
                m8 := mload(0x100)
    13725
                m9 := mload(0x120)
    13726
                m10 := mload(0x140)
    13727
                // Selector of `log(string,string,string,address)`.
    13728
                mstore(0x00, 0x6d572f44)
    13729
                mstore(0x20, 0x80)
    13730
                mstore(0x40, 0xc0)
    13731
                mstore(0x60, 0x100)
    13732
                mstore(0x80, p3)
    13733
                writeString(0xa0, p0)
    13734
                writeString(0xe0, p1)
    13735
                writeString(0x120, p2)
    13736
            }
    13737
            _sendLogPayload(0x1c, 0x144);
    13738
            /// @solidity memory-safe-assembly
    13739
            assembly {
    13740
                mstore(0x00, m0)
    13741
                mstore(0x20, m1)
    13742
                mstore(0x40, m2)
    13743
                mstore(0x60, m3)
    13744
                mstore(0x80, m4)
    13745
                mstore(0xa0, m5)
    13746
                mstore(0xc0, m6)
    13747
                mstore(0xe0, m7)
    13748
                mstore(0x100, m8)
    13749
                mstore(0x120, m9)
    13750
                mstore(0x140, m10)
    13751
            }
    13752
        }
    13753
    13754
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
    13755
            bytes32 m0;
    13756
            bytes32 m1;
    13757
            bytes32 m2;
    13758
            bytes32 m3;
    13759
            bytes32 m4;
    13760
            bytes32 m5;
    13761
            bytes32 m6;
    13762
            bytes32 m7;
    13763
            bytes32 m8;
    13764
            bytes32 m9;
    13765
            bytes32 m10;
    13766
            /// @solidity memory-safe-assembly
    13767
            assembly {
    13768
                function writeString(pos, w) {
    13769
                    let length := 0
    13770
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13771
                    mstore(pos, length)
    13772
                    let shift := sub(256, shl(3, length))
    13773
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13774
                }
    13775
                m0 := mload(0x00)
    13776
                m1 := mload(0x20)
    13777
                m2 := mload(0x40)
    13778
                m3 := mload(0x60)
    13779
                m4 := mload(0x80)
    13780
                m5 := mload(0xa0)
    13781
                m6 := mload(0xc0)
    13782
                m7 := mload(0xe0)
    13783
                m8 := mload(0x100)
    13784
                m9 := mload(0x120)
    13785
                m10 := mload(0x140)
    13786
                // Selector of `log(string,string,string,bool)`.
    13787
                mstore(0x00, 0x2c1754ed)
    13788
                mstore(0x20, 0x80)
    13789
                mstore(0x40, 0xc0)
    13790
                mstore(0x60, 0x100)
    13791
                mstore(0x80, p3)
    13792
                writeString(0xa0, p0)
    13793
                writeString(0xe0, p1)
    13794
                writeString(0x120, p2)
    13795
            }
    13796
            _sendLogPayload(0x1c, 0x144);
    13797
            /// @solidity memory-safe-assembly
    13798
            assembly {
    13799
                mstore(0x00, m0)
    13800
                mstore(0x20, m1)
    13801
                mstore(0x40, m2)
    13802
                mstore(0x60, m3)
    13803
                mstore(0x80, m4)
    13804
                mstore(0xa0, m5)
    13805
                mstore(0xc0, m6)
    13806
                mstore(0xe0, m7)
    13807
                mstore(0x100, m8)
    13808
                mstore(0x120, m9)
    13809
                mstore(0x140, m10)
    13810
            }
    13811
        }
    13812
    13813
        function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
    13814
            bytes32 m0;
    13815
            bytes32 m1;
    13816
            bytes32 m2;
    13817
            bytes32 m3;
    13818
            bytes32 m4;
    13819
            bytes32 m5;
    13820
            bytes32 m6;
    13821
            bytes32 m7;
    13822
            bytes32 m8;
    13823
            bytes32 m9;
    13824
            bytes32 m10;
    13825
            /// @solidity memory-safe-assembly
    13826
            assembly {
    13827
                function writeString(pos, w) {
    13828
                    let length := 0
    13829
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13830
                    mstore(pos, length)
    13831
                    let shift := sub(256, shl(3, length))
    13832
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13833
                }
    13834
                m0 := mload(0x00)
    13835
                m1 := mload(0x20)
    13836
                m2 := mload(0x40)
    13837
                m3 := mload(0x60)
    13838
                m4 := mload(0x80)
    13839
                m5 := mload(0xa0)
    13840
                m6 := mload(0xc0)
    13841
                m7 := mload(0xe0)
    13842
                m8 := mload(0x100)
    13843
                m9 := mload(0x120)
    13844
                m10 := mload(0x140)
    13845
                // Selector of `log(string,string,string,uint256)`.
    13846
                mstore(0x00, 0x8eafb02b)
    13847
                mstore(0x20, 0x80)
    13848
                mstore(0x40, 0xc0)
    13849
                mstore(0x60, 0x100)
    13850
                mstore(0x80, p3)
    13851
                writeString(0xa0, p0)
    13852
                writeString(0xe0, p1)
    13853
                writeString(0x120, p2)
    13854
            }
    13855
            _sendLogPayload(0x1c, 0x144);
    13856
            /// @solidity memory-safe-assembly
    13857
            assembly {
    13858
                mstore(0x00, m0)
    13859
                mstore(0x20, m1)
    13860
                mstore(0x40, m2)
    13861
                mstore(0x60, m3)
    13862
                mstore(0x80, m4)
    13863
                mstore(0xa0, m5)
    13864
                mstore(0xc0, m6)
    13865
                mstore(0xe0, m7)
    13866
                mstore(0x100, m8)
    13867
                mstore(0x120, m9)
    13868
                mstore(0x140, m10)
    13869
            }
    13870
        }
    13871
    13872
        function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
    13873
            bytes32 m0;
    13874
            bytes32 m1;
    13875
            bytes32 m2;
    13876
            bytes32 m3;
    13877
            bytes32 m4;
    13878
            bytes32 m5;
    13879
            bytes32 m6;
    13880
            bytes32 m7;
    13881
            bytes32 m8;
    13882
            bytes32 m9;
    13883
            bytes32 m10;
    13884
            bytes32 m11;
    13885
            bytes32 m12;
    13886
            /// @solidity memory-safe-assembly
    13887
            assembly {
    13888
                function writeString(pos, w) {
    13889
                    let length := 0
    13890
                    for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
    13891
                    mstore(pos, length)
    13892
                    let shift := sub(256, shl(3, length))
    13893
                    mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
    13894
                }
    13895
                m0 := mload(0x00)
    13896
                m1 := mload(0x20)
    13897
                m2 := mload(0x40)
    13898
                m3 := mload(0x60)
    13899
                m4 := mload(0x80)
    13900
                m5 := mload(0xa0)
    13901
                m6 := mload(0xc0)
    13902
                m7 := mload(0xe0)
    13903
                m8 := mload(0x100)
    13904
                m9 := mload(0x120)
    13905
                m10 := mload(0x140)
    13906
                m11 := mload(0x160)
    13907
                m12 := mload(0x180)
    13908
                // Selector of `log(string,string,string,string)`.
    13909
                mstore(0x00, 0xde68f20a)
    13910
                mstore(0x20, 0x80)
    13911
                mstore(0x40, 0xc0)
    13912
                mstore(0x60, 0x100)
    13913
                mstore(0x80, 0x140)
    13914
                writeString(0xa0, p0)
    13915
                writeString(0xe0, p1)
    13916
                writeString(0x120, p2)
    13917
                writeString(0x160, p3)
    13918
            }
    13919
            _sendLogPayload(0x1c, 0x184);
    13920
            /// @solidity memory-safe-assembly
    13921
            assembly {
    13922
                mstore(0x00, m0)
    13923
                mstore(0x20, m1)
    13924
                mstore(0x40, m2)
    13925
                mstore(0x60, m3)
    13926
                mstore(0x80, m4)
    13927
                mstore(0xa0, m5)
    13928
                mstore(0xc0, m6)
    13929
                mstore(0xe0, m7)
    13930
                mstore(0x100, m8)
    13931
                mstore(0x120, m9)
    13932
                mstore(0x140, m10)
    13933
                mstore(0x160, m11)
    13934
                mstore(0x180, m12)
    13935
            }
    13936
        }
    13937
    }
    13938
    60.0% lib/openzeppelin-contracts/contracts/access/Ownable.sol
    Lines covered: 6 / 10 (60.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
    3
    4
    pragma solidity ^0.8.20;
    5
    6
    import {Context} from "../utils/Context.sol";
    7
    8
    /**
    9
     * @dev Contract module which provides a basic access control mechanism, where
    10
     * there is an account (an owner) that can be granted exclusive access to
    11
     * specific functions.
    12
     *
    13
     * The initial owner is set to the address provided by the deployer. This can
    14
     * later be changed with {transferOwnership}.
    15
     *
    16
     * This module is used through inheritance. It will make available the modifier
    17
     * `onlyOwner`, which can be applied to your functions to restrict their use to
    18
     * the owner.
    19
     */
    20
    abstract contract Ownable is Context {
    21
        address private _owner;
    22
    23
        /**
    24
         * @dev The caller account is not authorized to perform an operation.
    25
         */
    26
        error OwnableUnauthorizedAccount(address account);
    27
    28
        /**
    29
         * @dev The owner is not a valid owner account. (eg. `address(0)`)
    30
         */
    31
        error OwnableInvalidOwner(address owner);
    32
    33
        event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    34
    35
        /**
    36
         * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
    37
         */
    38
        constructor(address initialOwner) {
    39
            if (initialOwner == address(0)) {
    40
                revert OwnableInvalidOwner(address(0));
    41
            }
    42
            _transferOwnership(initialOwner);
    43
        }
    44
    45
        /**
    46
         * @dev Throws if called by any account other than the owner.
    47
         */
    48
        modifier onlyOwner() {
    49
            _checkOwner();
    50
            _;
    51
        }
    52
    53
        /**
    54
         * @dev Returns the address of the current owner.
    55
         */
    56
        function owner() public view virtual returns (address) {
    57
            return _owner;
    58
        }
    59
    60
        /**
    61
         * @dev Throws if the sender is not the owner.
    62
         */
    63
        function _checkOwner() internal view virtual {
    64
            if (owner() != _msgSender()) {
    65
                revert OwnableUnauthorizedAccount(_msgSender());
    66
            }
    67
        }
    68
    69
        /**
    70
         * @dev Leaves the contract without owner. It will not be possible to call
    71
         * `onlyOwner` functions. Can only be called by the current owner.
    72
         *
    73
         * NOTE: Renouncing ownership will leave the contract without an owner,
    74
         * thereby disabling any functionality that is only available to the owner.
    75
         */
    76
        function renounceOwnership() public virtual onlyOwner {
    77
            _transferOwnership(address(0));
    78
        }
    79
    80
        /**
    81
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
    82
         * Can only be called by the current owner.
    83
         */
    84
        function transferOwnership(address newOwner) public virtual onlyOwner {
    85
            if (newOwner == address(0)) {
    86
                revert OwnableInvalidOwner(address(0));
    87
            }
    88
            _transferOwnership(newOwner);
    89
        }
    90
    91
        /**
    92
         * @dev Transfers ownership of the contract to a new account (`newOwner`).
    93
         * Internal function without access restriction.
    94
         */
    95
        function _transferOwnership(address newOwner) internal virtual {
    96
            address oldOwner = _owner;
    97
            _owner = newOwner;
    98
            emit OwnershipTransferred(oldOwner, newOwner);
    99
        }
    100
    }
    101
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)
    3
    4
    pragma solidity >=0.6.2;
    5
    6
    import {IERC20} from "./IERC20.sol";
    7
    import {IERC165} from "./IERC165.sol";
    8
    9
    /**
    10
     * @title IERC1363
    11
     * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
    12
     *
    13
     * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
    14
     * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
    15
     */
    16
    interface IERC1363 is IERC20, IERC165 {
    17
        /*
    18
         * Note: the ERC-165 identifier for this interface is 0xb0202a11.
    19
         * 0xb0202a11 ===
    20
         *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
    21
         *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
    22
         *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
    23
         *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
    24
         *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
    25
         *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
    26
         */
    27
    28
        /**
    29
         * @dev Moves a `value` amount of tokens from the caller's account to `to`
    30
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    31
         * @param to The address which you want to transfer to.
    32
         * @param value The amount of tokens to be transferred.
    33
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    34
         */
    35
        function transferAndCall(address to, uint256 value) external returns (bool);
    36
    37
        /**
    38
         * @dev Moves a `value` amount of tokens from the caller's account to `to`
    39
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    40
         * @param to The address which you want to transfer to.
    41
         * @param value The amount of tokens to be transferred.
    42
         * @param data Additional data with no specified format, sent in call to `to`.
    43
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    44
         */
    45
        function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
    46
    47
        /**
    48
         * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
    49
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    50
         * @param from The address which you want to send tokens from.
    51
         * @param to The address which you want to transfer to.
    52
         * @param value The amount of tokens to be transferred.
    53
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    54
         */
    55
        function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
    56
    57
        /**
    58
         * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
    59
         * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
    60
         * @param from The address which you want to send tokens from.
    61
         * @param to The address which you want to transfer to.
    62
         * @param value The amount of tokens to be transferred.
    63
         * @param data Additional data with no specified format, sent in call to `to`.
    64
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    65
         */
    66
        function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
    67
    68
        /**
    69
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    70
         * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
    71
         * @param spender The address which will spend the funds.
    72
         * @param value The amount of tokens to be spent.
    73
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    74
         */
    75
        function approveAndCall(address spender, uint256 value) external returns (bool);
    76
    77
        /**
    78
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    79
         * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
    80
         * @param spender The address which will spend the funds.
    81
         * @param value The amount of tokens to be spent.
    82
         * @param data Additional data with no specified format, sent in call to `spender`.
    83
         * @return A boolean value indicating whether the operation succeeded unless throwing.
    84
         */
    85
        function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
    86
    }
    87
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)
    3
    4
    pragma solidity >=0.4.16;
    5
    6
    import {IERC165} from "../utils/introspection/IERC165.sol";
    7
    0.0% lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)
    3
    4
    pragma solidity >=0.4.16;
    5
    6
    import {IERC20} from "../token/ERC20/IERC20.sol";
    7
    0.0% lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)
    3
    4
    pragma solidity >=0.8.4;
    5
    6
    /**
    7
     * @dev Standard ERC-20 Errors
    8
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
    9
     */
    10
    interface IERC20Errors {
    11
        /**
    12
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    13
         * @param sender Address whose tokens are being transferred.
    14
         * @param balance Current balance for the interacting account.
    15
         * @param needed Minimum amount required to perform a transfer.
    16
         */
    17
        error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    18
    19
        /**
    20
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    21
         * @param sender Address whose tokens are being transferred.
    22
         */
    23
        error ERC20InvalidSender(address sender);
    24
    25
        /**
    26
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    27
         * @param receiver Address to which tokens are being transferred.
    28
         */
    29
        error ERC20InvalidReceiver(address receiver);
    30
    31
        /**
    32
         * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
    33
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    34
         * @param allowance Amount of tokens a `spender` is allowed to operate with.
    35
         * @param needed Minimum amount required to perform a transfer.
    36
         */
    37
        error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    38
    39
        /**
    40
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    41
         * @param approver Address initiating an approval operation.
    42
         */
    43
        error ERC20InvalidApprover(address approver);
    44
    45
        /**
    46
         * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
    47
         * @param spender Address that may be allowed to operate on tokens without being their owner.
    48
         */
    49
        error ERC20InvalidSpender(address spender);
    50
    }
    51
    52
    /**
    53
     * @dev Standard ERC-721 Errors
    54
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
    55
     */
    56
    interface IERC721Errors {
    57
        /**
    58
         * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.
    59
         * Used in balance queries.
    60
         * @param owner Address of the current owner of a token.
    61
         */
    62
        error ERC721InvalidOwner(address owner);
    63
    64
        /**
    65
         * @dev Indicates a `tokenId` whose `owner` is the zero address.
    66
         * @param tokenId Identifier number of a token.
    67
         */
    68
        error ERC721NonexistentToken(uint256 tokenId);
    69
    70
        /**
    71
         * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
    72
         * @param sender Address whose tokens are being transferred.
    73
         * @param tokenId Identifier number of a token.
    74
         * @param owner Address of the current owner of a token.
    75
         */
    76
        error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
    77
    78
        /**
    79
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    80
         * @param sender Address whose tokens are being transferred.
    81
         */
    82
        error ERC721InvalidSender(address sender);
    83
    84
        /**
    85
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    86
         * @param receiver Address to which tokens are being transferred.
    87
         */
    88
        error ERC721InvalidReceiver(address receiver);
    89
    90
        /**
    91
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    92
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    93
         * @param tokenId Identifier number of a token.
    94
         */
    95
        error ERC721InsufficientApproval(address operator, uint256 tokenId);
    96
    97
        /**
    98
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    99
         * @param approver Address initiating an approval operation.
    100
         */
    101
        error ERC721InvalidApprover(address approver);
    102
    103
        /**
    104
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    105
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    106
         */
    107
        error ERC721InvalidOperator(address operator);
    108
    }
    109
    110
    /**
    111
     * @dev Standard ERC-1155 Errors
    112
     * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
    113
     */
    114
    interface IERC1155Errors {
    115
        /**
    116
         * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
    117
         * @param sender Address whose tokens are being transferred.
    118
         * @param balance Current balance for the interacting account.
    119
         * @param needed Minimum amount required to perform a transfer.
    120
         * @param tokenId Identifier number of a token.
    121
         */
    122
        error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
    123
    124
        /**
    125
         * @dev Indicates a failure with the token `sender`. Used in transfers.
    126
         * @param sender Address whose tokens are being transferred.
    127
         */
    128
        error ERC1155InvalidSender(address sender);
    129
    130
        /**
    131
         * @dev Indicates a failure with the token `receiver`. Used in transfers.
    132
         * @param receiver Address to which tokens are being transferred.
    133
         */
    134
        error ERC1155InvalidReceiver(address receiver);
    135
    136
        /**
    137
         * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
    138
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    139
         * @param owner Address of the current owner of a token.
    140
         */
    141
        error ERC1155MissingApprovalForAll(address operator, address owner);
    142
    143
        /**
    144
         * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
    145
         * @param approver Address initiating an approval operation.
    146
         */
    147
        error ERC1155InvalidApprover(address approver);
    148
    149
        /**
    150
         * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
    151
         * @param operator Address that may be allowed to operate on tokens without being their owner.
    152
         */
    153
        error ERC1155InvalidOperator(address operator);
    154
    155
        /**
    156
         * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
    157
         * Used in batch transfers.
    158
         * @param idsLength Length of the array of token identifiers
    159
         * @param valuesLength Length of the array of token amounts
    160
         */
    161
        error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
    162
    }
    163
    100.0% lib/openzeppelin-contracts/contracts/mocks/token/ERC20Mock.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.20;
    3
    4
    import {ERC20} from "../../token/ERC20/ERC20.sol";
    5
    6
    contract ERC20Mock is ERC20 {
    7
        constructor() ERC20("ERC20Mock", "E20M") {}
    8
    9
        function mint(address account, uint256 amount) external {
    10
            _mint(account, amount);
    11
        }
    12
    13
        function burn(address account, uint256 amount) external {
    14
            _burn(account, amount);
    15
        }
    16
    }
    17
    19.0% lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
    Lines covered: 5 / 26 (19.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol)
    3
    4
    pragma solidity ^0.8.20;
    5
    6
    import {IERC20} from "./IERC20.sol";
    7
    import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
    8
    import {Context} from "../../utils/Context.sol";
    9
    import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
    10
    11
    /**
    12
     * @dev Implementation of the {IERC20} interface.
    13
     *
    14
     * This implementation is agnostic to the way tokens are created. This means
    15
     * that a supply mechanism has to be added in a derived contract using {_mint}.
    16
     *
    17
     * TIP: For a detailed writeup see our guide
    18
     * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
    19
     * to implement supply mechanisms].
    20
     *
    21
     * The default value of {decimals} is 18. To change this, you should override
    22
     * this function so it returns a different value.
    23
     *
    24
     * We have followed general OpenZeppelin Contracts guidelines: functions revert
    25
     * instead returning `false` on failure. This behavior is nonetheless
    26
     * conventional and does not conflict with the expectations of ERC-20
    27
     * applications.
    28
     */
    29
    abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    30
        mapping(address account => uint256) private _balances;
    31
    32
        mapping(address account => mapping(address spender => uint256)) private _allowances;
    33
    34
        uint256 private _totalSupply;
    35
    36
        string private _name;
    37
        string private _symbol;
    38
    39
        /**
    40
         * @dev Sets the values for {name} and {symbol}.
    41
         *
    42
         * Both values are immutable: they can only be set once during construction.
    43
         */
    44
        constructor(string memory name_, string memory symbol_) {
    45
            _name = name_;
    46
            _symbol = symbol_;
    47
        }
    48
    49
        /**
    50
         * @dev Returns the name of the token.
    51
         */
    52
        function name() public view virtual returns (string memory) {
    53
            return _name;
    54
        }
    55
    56
        /**
    57
         * @dev Returns the symbol of the token, usually a shorter version of the
    58
         * name.
    59
         */
    60
        function symbol() public view virtual returns (string memory) {
    61
            return _symbol;
    62
        }
    63
    64
        /**
    65
         * @dev Returns the number of decimals used to get its user representation.
    66
         * For example, if `decimals` equals `2`, a balance of `505` tokens should
    67
         * be displayed to a user as `5.05` (`505 / 10 ** 2`).
    68
         *
    69
         * Tokens usually opt for a value of 18, imitating the relationship between
    70
         * Ether and Wei. This is the default value returned by this function, unless
    71
         * it's overridden.
    72
         *
    73
         * NOTE: This information is only used for _display_ purposes: it in
    74
         * no way affects any of the arithmetic of the contract, including
    75
         * {IERC20-balanceOf} and {IERC20-transfer}.
    76
         */
    77
        function decimals() public view virtual returns (uint8) {
    78
            return 18;
    79
        }
    80
    81
        /// @inheritdoc IERC20
    82
        function totalSupply() public view virtual returns (uint256) {
    83
            return _totalSupply;
    84
        }
    85
    86
        /// @inheritdoc IERC20
    87
        function balanceOf(address account) public view virtual returns (uint256) {
    88
            return _balances[account];
    89
        }
    90
    91
        /**
    92
         * @dev See {IERC20-transfer}.
    93
         *
    94
         * Requirements:
    95
         *
    96
         * - `to` cannot be the zero address.
    97
         * - the caller must have a balance of at least `value`.
    98
         */
    99
        function transfer(address to, uint256 value) public virtual returns (bool) {
    100
            address owner = _msgSender();
    101
            _transfer(owner, to, value);
    102
            return true;
    103
        }
    104
    105
        /// @inheritdoc IERC20
    106
        function allowance(address owner, address spender) public view virtual returns (uint256) {
    107
            return _allowances[owner][spender];
    108
        }
    109
    110
        /**
    111
         * @dev See {IERC20-approve}.
    112
         *
    113
         * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
    114
         * `transferFrom`. This is semantically equivalent to an infinite approval.
    115
         *
    116
         * Requirements:
    117
         *
    118
         * - `spender` cannot be the zero address.
    119
         */
    120
        function approve(address spender, uint256 value) public virtual returns (bool) {
    121
            address owner = _msgSender();
    122
            _approve(owner, spender, value);
    123
            return true;
    124
        }
    125
    126
        /**
    127
         * @dev See {IERC20-transferFrom}.
    128
         *
    129
         * Skips emitting an {Approval} event indicating an allowance update. This is not
    130
         * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
    131
         *
    132
         * NOTE: Does not update the allowance if the current allowance
    133
         * is the maximum `uint256`.
    134
         *
    135
         * Requirements:
    136
         *
    137
         * - `from` and `to` cannot be the zero address.
    138
         * - `from` must have a balance of at least `value`.
    139
         * - the caller must have allowance for ``from``'s tokens of at least
    140
         * `value`.
    141
         */
    142
        function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
    143
            address spender = _msgSender();
    144
            _spendAllowance(from, spender, value);
    145
            _transfer(from, to, value);
    146
            return true;
    147
        }
    148
    149
        /**
    150
         * @dev Moves a `value` amount of tokens from `from` to `to`.
    151
         *
    152
         * This internal function is equivalent to {transfer}, and can be used to
    153
         * e.g. implement automatic token fees, slashing mechanisms, etc.
    154
         *
    155
         * Emits a {Transfer} event.
    156
         *
    157
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    158
         */
    159
        function _transfer(address from, address to, uint256 value) internal {
    160
            if (from == address(0)) {
    161
                revert ERC20InvalidSender(address(0));
    162
            }
    163
            if (to == address(0)) {
    164
                revert ERC20InvalidReceiver(address(0));
    165
            }
    166
            _update(from, to, value);
    167
        }
    168
    169
        /**
    170
         * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
    171
         * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
    172
         * this function.
    173
         *
    174
         * Emits a {Transfer} event.
    175
         */
    176
        function _update(address from, address to, uint256 value) internal virtual {
    177
            if (from == address(0)) {
    178
                // Overflow check required: The rest of the code assumes that totalSupply never overflows
    179
                _totalSupply += value;
    180
            } else {
    181
                uint256 fromBalance = _balances[from];
    182
                if (fromBalance < value) {
    183
                    revert ERC20InsufficientBalance(from, fromBalance, value);
    184
                }
    185
                unchecked {
    186
                    // Overflow not possible: value <= fromBalance <= totalSupply.
    187
                    _balances[from] = fromBalance - value;
    188
                }
    189
            }
    190
    191
            if (to == address(0)) {
    192
                unchecked {
    193
                    // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
    194
                    _totalSupply -= value;
    195
                }
    196
            } else {
    197
                unchecked {
    198
                    // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
    199
                    _balances[to] += value;
    200
                }
    201
            }
    202
    203
            emit Transfer(from, to, value);
    204
        }
    205
    206
        /**
    207
         * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
    208
         * Relies on the `_update` mechanism
    209
         *
    210
         * Emits a {Transfer} event with `from` set to the zero address.
    211
         *
    212
         * NOTE: This function is not virtual, {_update} should be overridden instead.
    213
         */
    214
        function _mint(address account, uint256 value) internal {
    215
            if (account == address(0)) {
    216
                revert ERC20InvalidReceiver(address(0));
    217
            }
    218
            _update(address(0), account, value);
    219
        }
    220
    221
        /**
    222
         * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
    223
         * Relies on the `_update` mechanism.
    224
         *
    225
         * Emits a {Transfer} event with `to` set to the zero address.
    226
         *
    227
         * NOTE: This function is not virtual, {_update} should be overridden instead
    228
         */
    229
        function _burn(address account, uint256 value) internal {
    230
            if (account == address(0)) {
    231
                revert ERC20InvalidSender(address(0));
    232
            }
    233
            _update(account, address(0), value);
    234
        }
    235
    236
        /**
    237
         * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
    238
         *
    239
         * This internal function is equivalent to `approve`, and can be used to
    240
         * e.g. set automatic allowances for certain subsystems, etc.
    241
         *
    242
         * Emits an {Approval} event.
    243
         *
    244
         * Requirements:
    245
         *
    246
         * - `owner` cannot be the zero address.
    247
         * - `spender` cannot be the zero address.
    248
         *
    249
         * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
    250
         */
    251
        function _approve(address owner, address spender, uint256 value) internal {
    252
            _approve(owner, spender, value, true);
    253
        }
    254
    255
        /**
    256
         * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
    257
         *
    258
         * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
    259
         * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any
    260
         * `Approval` event during `transferFrom` operations.
    261
         *
    262
         * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to
    263
         * true using the following override:
    264
         *
    265
         * ```solidity
    266
         * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
    267
         *     super._approve(owner, spender, value, true);
    268
         * }
    269
         * ```
    270
         *
    271
         * Requirements are the same as {_approve}.
    272
         */
    273
        function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
    274
            if (owner == address(0)) {
    275
                revert ERC20InvalidApprover(address(0));
    276
            }
    277
            if (spender == address(0)) {
    278
                revert ERC20InvalidSpender(address(0));
    279
            }
    280
            _allowances[owner][spender] = value;
    281
            if (emitEvent) {
    282
                emit Approval(owner, spender, value);
    283
            }
    284
        }
    285
    286
        /**
    287
         * @dev Updates `owner`'s allowance for `spender` based on spent `value`.
    288
         *
    289
         * Does not update the allowance value in case of infinite allowance.
    290
         * Revert if not enough allowance is available.
    291
         *
    292
         * Does not emit an {Approval} event.
    293
         */
    294
        function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
    295
            uint256 currentAllowance = allowance(owner, spender);
    296
            if (currentAllowance < type(uint256).max) {
    297
                if (currentAllowance < value) {
    298
                    revert ERC20InsufficientAllowance(spender, currentAllowance, value);
    299
                }
    300
                unchecked {
    301
                    _approve(owner, spender, currentAllowance - value, false);
    302
                }
    303
            }
    304
        }
    305
    }
    306
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)
    3
    4
    pragma solidity >=0.4.16;
    5
    6
    /**
    7
     * @dev Interface of the ERC-20 standard as defined in the ERC.
    8
     */
    9
    interface IERC20 {
    10
        /**
    11
         * @dev Emitted when `value` tokens are moved from one account (`from`) to
    12
         * another (`to`).
    13
         *
    14
         * Note that `value` may be zero.
    15
         */
    16
        event Transfer(address indexed from, address indexed to, uint256 value);
    17
    18
        /**
    19
         * @dev Emitted when the allowance of a `spender` for an `owner` is set by
    20
         * a call to {approve}. `value` is the new allowance.
    21
         */
    22
        event Approval(address indexed owner, address indexed spender, uint256 value);
    23
    24
        /**
    25
         * @dev Returns the value of tokens in existence.
    26
         */
    27
        function totalSupply() external view returns (uint256);
    28
    29
        /**
    30
         * @dev Returns the value of tokens owned by `account`.
    31
         */
    32
        function balanceOf(address account) external view returns (uint256);
    33
    34
        /**
    35
         * @dev Moves a `value` amount of tokens from the caller's account to `to`.
    36
         *
    37
         * Returns a boolean value indicating whether the operation succeeded.
    38
         *
    39
         * Emits a {Transfer} event.
    40
         */
    41
        function transfer(address to, uint256 value) external returns (bool);
    42
    43
        /**
    44
         * @dev Returns the remaining number of tokens that `spender` will be
    45
         * allowed to spend on behalf of `owner` through {transferFrom}. This is
    46
         * zero by default.
    47
         *
    48
         * This value changes when {approve} or {transferFrom} are called.
    49
         */
    50
        function allowance(address owner, address spender) external view returns (uint256);
    51
    52
        /**
    53
         * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
    54
         * caller's tokens.
    55
         *
    56
         * Returns a boolean value indicating whether the operation succeeded.
    57
         *
    58
         * IMPORTANT: Beware that changing an allowance with this method brings the risk
    59
         * that someone may use both the old and the new allowance by unfortunate
    60
         * transaction ordering. One possible solution to mitigate this race
    61
         * condition is to first reduce the spender's allowance to 0 and set the
    62
         * desired value afterwards:
    63
         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    64
         *
    65
         * Emits an {Approval} event.
    66
         */
    67
        function approve(address spender, uint256 value) external returns (bool);
    68
    69
        /**
    70
         * @dev Moves a `value` amount of tokens from `from` to `to` using the
    71
         * allowance mechanism. `value` is then deducted from the caller's
    72
         * allowance.
    73
         *
    74
         * Returns a boolean value indicating whether the operation succeeded.
    75
         *
    76
         * Emits a {Transfer} event.
    77
         */
    78
        function transferFrom(address from, address to, uint256 value) external returns (bool);
    79
    }
    80
    0.0% lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)
    3
    4
    pragma solidity >=0.6.2;
    5
    6
    import {IERC20} from "../IERC20.sol";
    7
    8
    /**
    9
     * @dev Interface for the optional metadata functions from the ERC-20 standard.
    10
     */
    11
    interface IERC20Metadata is IERC20 {
    12
        /**
    13
         * @dev Returns the name of the token.
    14
         */
    15
        function name() external view returns (string memory);
    16
    17
        /**
    18
         * @dev Returns the symbol of the token.
    19
         */
    20
        function symbol() external view returns (string memory);
    21
    22
        /**
    23
         * @dev Returns the decimals places of the token.
    24
         */
    25
        function decimals() external view returns (uint8);
    26
    }
    27
    10.0% lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol
    Lines covered: 1 / 10 (10.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)
    3
    4
    pragma solidity ^0.8.20;
    5
    6
    import {IERC20} from "../IERC20.sol";
    7
    import {IERC1363} from "../../../interfaces/IERC1363.sol";
    8
    9
    /**
    10
     * @title SafeERC20
    11
     * @dev Wrappers around ERC-20 operations that throw on failure (when the token
    12
     * contract returns false). Tokens that return no value (and instead revert or
    13
     * throw on failure) are also supported, non-reverting calls are assumed to be
    14
     * successful.
    15
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
    16
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
    17
     */
    18
    library SafeERC20 {
    19
        /**
    20
         * @dev An operation with an ERC-20 token failed.
    21
         */
    22
        error SafeERC20FailedOperation(address token);
    23
    24
        /**
    25
         * @dev Indicates a failed `decreaseAllowance` request.
    26
         */
    27
        error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
    28
    29
        /**
    30
         * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
    31
         * non-reverting calls are assumed to be successful.
    32
         */
    33
        function safeTransfer(IERC20 token, address to, uint256 value) internal {
    34
            if (!_safeTransfer(token, to, value, true)) {
    35
                revert SafeERC20FailedOperation(address(token));
    36
            }
    37
        }
    38
    39
        /**
    40
         * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
    41
         * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
    42
         */
    43
        function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
    44
            if (!_safeTransferFrom(token, from, to, value, true)) {
    45
                revert SafeERC20FailedOperation(address(token));
    46
            }
    47
        }
    48
    49
        /**
    50
         * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
    51
         */
    52
        function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
    53
            return _safeTransfer(token, to, value, false);
    54
        }
    55
    56
        /**
    57
         * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
    58
         */
    59
        function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
    60
            return _safeTransferFrom(token, from, to, value, false);
    61
        }
    62
    63
        /**
    64
         * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
    65
         * non-reverting calls are assumed to be successful.
    66
         *
    67
         * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
    68
         * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
    69
         * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
    70
         * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
    71
         */
    72
        function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    73
            uint256 oldAllowance = token.allowance(address(this), spender);
    74
            forceApprove(token, spender, oldAllowance + value);
    75
        }
    76
    77
        /**
    78
         * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
    79
         * value, non-reverting calls are assumed to be successful.
    80
         *
    81
         * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
    82
         * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
    83
         * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
    84
         * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
    85
         */
    86
        function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
    87
            unchecked {
    88
                uint256 currentAllowance = token.allowance(address(this), spender);
    89
                if (currentAllowance < requestedDecrease) {
    90
                    revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
    91
                }
    92
                forceApprove(token, spender, currentAllowance - requestedDecrease);
    93
            }
    94
        }
    95
    96
        /**
    97
         * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
    98
         * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
    99
         * to be set to zero before setting it to a non-zero value, such as USDT.
    100
         *
    101
         * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
    102
         * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
    103
         * set here.
    104
         */
    105
        function forceApprove(IERC20 token, address spender, uint256 value) internal {
    106
            if (!_safeApprove(token, spender, value, false)) {
    107
                if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));
    108
                if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));
    109
            }
    110
        }
    111
    112
        /**
    113
         * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
    114
         * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
    115
         * targeting contracts.
    116
         *
    117
         * Reverts if the returned value is other than `true`.
    118
         */
    119
        function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
    120
            if (to.code.length == 0) {
    121
                safeTransfer(token, to, value);
    122
            } else if (!token.transferAndCall(to, value, data)) {
    123
                revert SafeERC20FailedOperation(address(token));
    124
            }
    125
        }
    126
    127
        /**
    128
         * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
    129
         * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
    130
         * targeting contracts.
    131
         *
    132
         * Reverts if the returned value is other than `true`.
    133
         */
    134
        function transferFromAndCallRelaxed(
    135
            IERC1363 token,
    136
            address from,
    137
            address to,
    138
            uint256 value,
    139
            bytes memory data
    140
        ) internal {
    141
            if (to.code.length == 0) {
    142
                safeTransferFrom(token, from, to, value);
    143
            } else if (!token.transferFromAndCall(from, to, value, data)) {
    144
                revert SafeERC20FailedOperation(address(token));
    145
            }
    146
        }
    147
    148
        /**
    149
         * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
    150
         * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
    151
         * targeting contracts.
    152
         *
    153
         * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
    154
         * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
    155
         * once without retrying, and relies on the returned value to be true.
    156
         *
    157
         * Reverts if the returned value is other than `true`.
    158
         */
    159
        function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
    160
            if (to.code.length == 0) {
    161
                forceApprove(token, to, value);
    162
            } else if (!token.approveAndCall(to, value, data)) {
    163
                revert SafeERC20FailedOperation(address(token));
    164
            }
    165
        }
    166
    167
        /**
    168
         * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the
    169
         * return value is optional (but if data is returned, it must not be false).
    170
         *
    171
         * @param token The token targeted by the call.
    172
         * @param to The recipient of the tokens
    173
         * @param value The amount of token to transfer
    174
         * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
    175
         */
    176
        function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {
    177
            bytes4 selector = IERC20.transfer.selector;
    178
    179
            assembly ("memory-safe") {
    180
                let fmp := mload(0x40)
    181
                mstore(0x00, selector)
    182
                mstore(0x04, and(to, shr(96, not(0))))
    183
                mstore(0x24, value)
    184
                success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
    185
                // if call success and return is true, all is good.
    186
                // otherwise (not success or return is not true), we need to perform further checks
    187
                if iszero(and(success, eq(mload(0x00), 1))) {
    188
                    // if the call was a failure and bubble is enabled, bubble the error
    189
                    if and(iszero(success), bubble) {
    190
                        returndatacopy(fmp, 0x00, returndatasize())
    191
                        revert(fmp, returndatasize())
    192
                    }
    193
                    // if the return value is not true, then the call is only successful if:
    194
                    // - the token address has code
    195
                    // - the returndata is empty
    196
                    success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
    197
                }
    198
                mstore(0x40, fmp)
    199
            }
    200
        }
    201
    202
        /**
    203
         * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return
    204
         * value: the return value is optional (but if data is returned, it must not be false).
    205
         *
    206
         * @param token The token targeted by the call.
    207
         * @param from The sender of the tokens
    208
         * @param to The recipient of the tokens
    209
         * @param value The amount of token to transfer
    210
         * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
    211
         */
    212
        function _safeTransferFrom(
    213
            IERC20 token,
    214
            address from,
    215
            address to,
    216
            uint256 value,
    217
            bool bubble
    218
        ) private returns (bool success) {
    219
            bytes4 selector = IERC20.transferFrom.selector;
    220
    221
            assembly ("memory-safe") {
    222
                let fmp := mload(0x40)
    223
                mstore(0x00, selector)
    224
                mstore(0x04, and(from, shr(96, not(0))))
    225
                mstore(0x24, and(to, shr(96, not(0))))
    226
                mstore(0x44, value)
    227
                success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)
    228
                // if call success and return is true, all is good.
    229
                // otherwise (not success or return is not true), we need to perform further checks
    230
                if iszero(and(success, eq(mload(0x00), 1))) {
    231
                    // if the call was a failure and bubble is enabled, bubble the error
    232
                    if and(iszero(success), bubble) {
    233
                        returndatacopy(fmp, 0x00, returndatasize())
    234
                        revert(fmp, returndatasize())
    235
                    }
    236
                    // if the return value is not true, then the call is only successful if:
    237
                    // - the token address has code
    238
                    // - the returndata is empty
    239
                    success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
    240
                }
    241
                mstore(0x40, fmp)
    242
                mstore(0x60, 0)
    243
            }
    244
        }
    245
    246
        /**
    247
         * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:
    248
         * the return value is optional (but if data is returned, it must not be false).
    249
         *
    250
         * @param token The token targeted by the call.
    251
         * @param spender The spender of the tokens
    252
         * @param value The amount of token to transfer
    253
         * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
    254
         */
    255
        function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {
    256
            bytes4 selector = IERC20.approve.selector;
    257
    258
            assembly ("memory-safe") {
    259
                let fmp := mload(0x40)
    260
                mstore(0x00, selector)
    261
                mstore(0x04, and(spender, shr(96, not(0))))
    262
                mstore(0x24, value)
    263
                success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
    264
                // if call success and return is true, all is good.
    265
                // otherwise (not success or return is not true), we need to perform further checks
    266
                if iszero(and(success, eq(mload(0x00), 1))) {
    267
                    // if the call was a failure and bubble is enabled, bubble the error
    268
                    if and(iszero(success), bubble) {
    269
                        returndatacopy(fmp, 0x00, returndatasize())
    270
                        revert(fmp, returndatasize())
    271
                    }
    272
                    // if the return value is not true, then the call is only successful if:
    273
                    // - the token address has code
    274
                    // - the returndata is empty
    275
                    success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
    276
                }
    277
                mstore(0x40, fmp)
    278
            }
    279
        }
    280
    }
    281
    100.0% lib/openzeppelin-contracts/contracts/utils/Context.sol
    Lines covered: 1 / 1 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
    3
    4
    pragma solidity ^0.8.20;
    5
    6
    /**
    7
     * @dev Provides information about the current execution context, including the
    8
     * sender of the transaction and its data. While these are generally available
    9
     * via msg.sender and msg.data, they should not be accessed in such a direct
    10
     * manner, since when dealing with meta-transactions the account sending and
    11
     * paying for execution may not be the actual sender (as far as an application
    12
     * is concerned).
    13
     *
    14
     * This contract is only required for intermediate, library-like contracts.
    15
     */
    16
    abstract contract Context {
    17
        function _msgSender() internal view virtual returns (address) {
    18
            return msg.sender;
    19
        }
    20
    21
        function _msgData() internal view virtual returns (bytes calldata) {
    22
            return msg.data;
    23
        }
    24
    25
        function _contextSuffixLength() internal view virtual returns (uint256) {
    26
            return 0;
    27
        }
    28
    }
    29
    14.0% lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol
    Lines covered: 1 / 7 (14.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)
    3
    4
    pragma solidity ^0.8.20;
    5
    6
    import {StorageSlot} from "./StorageSlot.sol";
    7
    8
    /**
    9
     * @dev Contract module that helps prevent reentrant calls to a function.
    10
     *
    11
     * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
    12
     * available, which can be applied to functions to make sure there are no nested
    13
     * (reentrant) calls to them.
    14
     *
    15
     * Note that because there is a single `nonReentrant` guard, functions marked as
    16
     * `nonReentrant` may not call one another. This can be worked around by making
    17
     * those functions `private`, and then adding `external` `nonReentrant` entry
    18
     * points to them.
    19
     *
    20
     * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
    21
     * consider using {ReentrancyGuardTransient} instead.
    22
     *
    23
     * TIP: If you would like to learn more about reentrancy and alternative ways
    24
     * to protect against it, check out our blog post
    25
     * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
    26
     *
    27
     * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced
    28
     * by the {ReentrancyGuardTransient} variant in v6.0.
    29
     *
    30
     * @custom:stateless
    31
     */
    32
    abstract contract ReentrancyGuard {
    33
        using StorageSlot for bytes32;
    34
    35
        // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    36
        bytes32 private constant REENTRANCY_GUARD_STORAGE =
    37
            0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
    38
    39
        // Booleans are more expensive than uint256 or any type that takes up a full
    40
        // word because each write operation emits an extra SLOAD to first read the
    41
        // slot's contents, replace the bits taken up by the boolean, and then write
    42
        // back. This is the compiler's defense against contract upgrades and
    43
        // pointer aliasing, and it cannot be disabled.
    44
    45
        // The values being non-zero value makes deployment a bit more expensive,
    46
        // but in exchange the refund on every call to nonReentrant will be lower in
    47
        // amount. Since refunds are capped to a percentage of the total
    48
        // transaction's gas, it is best to keep them low in cases like this one, to
    49
        // increase the likelihood of the full refund coming into effect.
    50
        uint256 private constant NOT_ENTERED = 1;
    51
        uint256 private constant ENTERED = 2;
    52
    53
        /**
    54
         * @dev Unauthorized reentrant call.
    55
         */
    56
        error ReentrancyGuardReentrantCall();
    57
    58
        constructor() {
    59
            _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;
    60
        }
    61
    62
        /**
    63
         * @dev Prevents a contract from calling itself, directly or indirectly.
    64
         * Calling a `nonReentrant` function from another `nonReentrant`
    65
         * function is not supported. It is possible to prevent this from happening
    66
         * by making the `nonReentrant` function external, and making it call a
    67
         * `private` function that does the actual work.
    68
         */
    69
        modifier nonReentrant() {
    70
            _nonReentrantBefore();
    71
            _;
    72
            _nonReentrantAfter();
    73
        }
    74
    75
        /**
    76
         * @dev A `view` only version of {nonReentrant}. Use to block view functions
    77
         * from being called, preventing reading from inconsistent contract state.
    78
         *
    79
         * CAUTION: This is a "view" modifier and does not change the reentrancy
    80
         * status. Use it only on view functions. For payable or non-payable functions,
    81
         * use the standard {nonReentrant} modifier instead.
    82
         */
    83
        modifier nonReentrantView() {
    84
            _nonReentrantBeforeView();
    85
            _;
    86
        }
    87
    88
        function _nonReentrantBeforeView() private view {
    89
            if (_reentrancyGuardEntered()) {
    90
                revert ReentrancyGuardReentrantCall();
    91
            }
    92
        }
    93
    94
        function _nonReentrantBefore() private {
    95
            // On the first call to nonReentrant, _status will be NOT_ENTERED
    96
            _nonReentrantBeforeView();
    97
    98
            // Any calls to nonReentrant after this point will fail
    99
            _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;
    100
        }
    101
    102
        function _nonReentrantAfter() private {
    103
            // By storing the original value once again, a refund is triggered (see
    104
            // https://eips.ethereum.org/EIPS/eip-2200)
    105
            _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;
    106
        }
    107
    108
        /**
    109
         * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
    110
         * `nonReentrant` function in the call stack.
    111
         */
    112
        function _reentrancyGuardEntered() internal view returns (bool) {
    113
            return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;
    114
        }
    115
    116
        function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {
    117
            return REENTRANCY_GUARD_STORAGE;
    118
        }
    119
    }
    120
    0.0% lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol
    Lines covered: 0 / 1 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
    3
    // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
    4
    5
    pragma solidity ^0.8.20;
    6
    7
    /**
    8
     * @dev Library for reading and writing primitive types to specific storage slots.
    9
     *
    10
     * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
    11
     * This library helps with reading and writing to such slots without the need for inline assembly.
    12
     *
    13
     * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
    14
     *
    15
     * Example usage to set ERC-1967 implementation slot:
    16
     * ```solidity
    17
     * contract ERC1967 {
    18
     *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
    19
     *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    20
     *
    21
     *     function _getImplementation() internal view returns (address) {
    22
     *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    23
     *     }
    24
     *
    25
     *     function _setImplementation(address newImplementation) internal {
    26
     *         require(newImplementation.code.length > 0);
    27
     *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    28
     *     }
    29
     * }
    30
     * ```
    31
     *
    32
     * TIP: Consider using this library along with {SlotDerivation}.
    33
     */
    34
    library StorageSlot {
    35
        struct AddressSlot {
    36
            address value;
    37
        }
    38
    39
        struct BooleanSlot {
    40
            bool value;
    41
        }
    42
    43
        struct Bytes32Slot {
    44
            bytes32 value;
    45
        }
    46
    47
        struct Uint256Slot {
    48
            uint256 value;
    49
        }
    50
    51
        struct Int256Slot {
    52
            int256 value;
    53
        }
    54
    55
        struct StringSlot {
    56
            string value;
    57
        }
    58
    59
        struct BytesSlot {
    60
            bytes value;
    61
        }
    62
    63
        /**
    64
         * @dev Returns an `AddressSlot` with member `value` located at `slot`.
    65
         */
    66
        function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
    67
            assembly ("memory-safe") {
    68
                r.slot := slot
    69
            }
    70
        }
    71
    72
        /**
    73
         * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
    74
         */
    75
        function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
    76
            assembly ("memory-safe") {
    77
                r.slot := slot
    78
            }
    79
        }
    80
    81
        /**
    82
         * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
    83
         */
    84
        function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
    85
            assembly ("memory-safe") {
    86
                r.slot := slot
    87
            }
    88
        }
    89
    90
        /**
    91
         * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
    92
         */
    93
        function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
    94
            assembly ("memory-safe") {
    95
                r.slot := slot
    96
            }
    97
        }
    98
    99
        /**
    100
         * @dev Returns a `Int256Slot` with member `value` located at `slot`.
    101
         */
    102
        function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
    103
            assembly ("memory-safe") {
    104
                r.slot := slot
    105
            }
    106
        }
    107
    108
        /**
    109
         * @dev Returns a `StringSlot` with member `value` located at `slot`.
    110
         */
    111
        function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
    112
            assembly ("memory-safe") {
    113
                r.slot := slot
    114
            }
    115
        }
    116
    117
        /**
    118
         * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
    119
         */
    120
        function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
    121
            assembly ("memory-safe") {
    122
                r.slot := store.slot
    123
            }
    124
        }
    125
    126
        /**
    127
         * @dev Returns a `BytesSlot` with member `value` located at `slot`.
    128
         */
    129
        function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
    130
            assembly ("memory-safe") {
    131
                r.slot := slot
    132
            }
    133
        }
    134
    135
        /**
    136
         * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
    137
         */
    138
        function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
    139
            assembly ("memory-safe") {
    140
                r.slot := store.slot
    141
            }
    142
        }
    143
    }
    144
    0.0% lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    // OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)
    3
    4
    pragma solidity >=0.4.16;
    5
    6
    /**
    7
     * @dev Interface of the ERC-165 standard, as defined in the
    8
     * https://eips.ethereum.org/EIPS/eip-165[ERC].
    9
     *
    10
     * Implementers can declare support of contract interfaces, which can then be
    11
     * queried by others ({ERC165Checker}).
    12
     *
    13
     * For an implementation, see {ERC165}.
    14
     */
    15
    interface IERC165 {
    16
        /**
    17
         * @dev Returns true if this contract implements the interface defined by
    18
         * `interfaceId`. See the corresponding
    19
         * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
    20
         * to learn more about how these ids are created.
    21
         *
    22
         * This function call must use less than 30 000 gas.
    23
         */
    24
        function supportsInterface(bytes4 interfaceId) external view returns (bool);
    25
    }
    26
    57.0% src/CreditPolicy.sol
    Lines covered: 60 / 104 (57.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";
    4
    5
    6
    /**
    7
     * @title CreditPolicy
    8
     * @notice Immutable-by-version credit constitution for private credit funds
    9
     */
    10
    contract CreditPolicy is ICreditPolicy {
    11
        /*//////////////////////////////////////////////////////////////
    12
                                    ERRORS
    13
        //////////////////////////////////////////////////////////////*/
    14
        error CreditPolicy__Unauthorized();
    15
        error CreditPolicy__PolicyFrozen(uint256 version);
    16
        error CreditPolicy__InvalidVersion();
    17
        error CreditPolicy__PolicyVersionExists(uint256 version);
    18
        error CreditPolicy__InvalidAdmin();
    19
        error CreditPolicy__PolicyNotEditable(uint256 version);
    20
        error CreditPolicy__IncompletePolicy(uint256 version);
    21
        error CreditPolicy__InvalidIndustryHash();
    22
        error CreditPolicy__PolicyNotActive(uint256 version);
    23
        error CreditPolicy__InvalidTierCount(uint256 count);
    24
        /*//////////////////////////////////////////////////////////////
    25
                                    MODIFIERS
    26
        //////////////////////////////////////////////////////////////*/
    27
        modifier onlyAdmin() {
    28
            _onlyAdmin();
    29
            _;
    30
        }
    31
    32
        function _onlyAdmin() internal view {
    33
            if (msg.sender != policyAdmin) revert CreditPolicy__Unauthorized();
    34
        }
    35
    36
        modifier policyEditable(uint256 version) {
    37
            _policyEditable(version);
    38
            _;
    39
        }
    40
    41
        function _policyEditable(uint256 version) internal view {
    42
            if (policyFrozen[version] || !policyActive[version])
    43
                revert CreditPolicy__PolicyNotEditable(version);
    44
        }
    45
    46
        modifier policyExists(uint256 version) {
    47
            _policyExists(version);
    48
            _;
    49
        }
    50
    51
        function _policyExists(uint256 version) internal view {
    52
            if (!policyCreated[version]) revert CreditPolicy__InvalidVersion();
    53
        }
    54
    55
        /*//////////////////////////////////////////////////////////////
    56
                                    CORE ROLES
    57
        //////////////////////////////////////////////////////////////*/
    58
        address public policyAdmin;
    59
        uint8 internal maxTiers;
    60
    61
        /*//////////////////////////////////////////////////////////////
    62
                                POLICY LIFECYCLE
    63
        //////////////////////////////////////////////////////////////*/
    64
        mapping(uint256 => bool) public policyCreated;
    65
        mapping(uint256 => bool) public policyFrozen;
    66
        mapping(uint256 => bool) public policyActive;
    67
        mapping(uint256 => uint256) public lastUpdated;
    68
    69
        /*//////////////////////////////////////////////////////////////
    70
                            ELIGIBILITY (PRE-LOAN)
    71
        //////////////////////////////////////////////////////////////*/
    72
        struct EligibilityCriteria {
    73
            uint256 minAnnualRevenue;
    74
            uint256 minEBITDA;
    75
            uint256 minTangibleNetWorth;
    76
            uint256 minBusinessAgeDays;
    77
            uint256 maxDefaultsLast36Months;
    78
            bool bankruptcyExcluded;
    79
        }
    80
    81
        mapping(uint256 => EligibilityCriteria) public eligibility;
    82
    83
        /*//////////////////////////////////////////////////////////////
    84
                            FINANCIAL RATIOS (UNDERWRITING)
    85
        //////////////////////////////////////////////////////////////*/
    86
        struct FinancialRatios {
    87
            uint256 maxTotalDebtToEBITDA;
    88
            uint256 minInterestCoverageRatio;
    89
            uint256 minCurrentRatio;
    90
            uint256 minEBITDAMarginBps;
    91
        }
    92
    93
        mapping(uint256 => FinancialRatios) public ratios;
    94
    95
        /*//////////////////////////////////////////////////////////////
    96
                            LOAN TIERS (PRICING REFERENCE)
    97
        //////////////////////////////////////////////////////////////*/
    98
        struct LoanTier {
    99
            string name;
    100
            uint256 minRevenue;
    101
            uint256 maxRevenue;
    102
            uint256 minEBITDA;
    103
            uint256 maxDebtToEBITDA;
    104
            uint256 maxLoanToEBITDA;
    105
            uint256 interestRateBps;
    106
            uint256 originationFeeBps;
    107
            uint256 termDays;
    108
            bool active;
    109
        }
    110
    111
        mapping(uint256 => mapping(uint8 => LoanTier)) public loanTiers;
    112
        mapping(uint256 => uint8) public totalTiers;
    113
        mapping(uint256 => mapping(uint8 => bool)) public tierExists;
    114
    115
        /*//////////////////////////////////////////////////////////////
    116
                            CONCENTRATION LIMITS
    117
        //////////////////////////////////////////////////////////////*/
    118
        struct ConcentrationLimits {
    119
            uint256 maxSingleBorrowerBps;
    120
            uint256 maxIndustryConcentrationBps;
    121
        }
    122
    123
        mapping(uint256 => ConcentrationLimits) public concentration;
    124
    125
        /*//////////////////////////////////////////////////////////////
    126
                            INDUSTRY EXCLUSIONS
    127
        //////////////////////////////////////////////////////////////*/
    128
        mapping(uint256 => mapping(bytes32 => bool)) public excludedIndustries;
    129
    130
        /*//////////////////////////////////////////////////////////////
    131
                            ATTESTATION REQUIREMENTS
    132
        //////////////////////////////////////////////////////////////*/
    133
        struct AttestationRequirements {
    134
            uint256 maxAttestationAgeDays;
    135
            uint256 reAttestationFrequencyDays;
    136
            bool requiresCPAAttestation;
    137
        }
    138
    139
        mapping(uint256 => AttestationRequirements) public attestation;
    140
    141
        /*//////////////////////////////////////////////////////////////
    142
                            MAINTENANCE COVENANTS
    143
        //////////////////////////////////////////////////////////////*/
    144
        struct MaintenanceCovenants {
    145
            uint256 maxLeverageRatio;
    146
            uint256 minCoverageRatio;
    147
            uint256 minLiquidityAmount;
    148
            bool allowsDividends;
    149
            uint256 reportingFrequencyDays;
    150
        }
    151
    152
        mapping(uint256 => MaintenanceCovenants) public covenants;
    153
    154
        /*//////////////////////////////////////////////////////////////
    155
                            DOCUMENT ANCHORING
    156
        //////////////////////////////////////////////////////////////*/
    157
        mapping(uint256 => bytes32) public policyDocumentHash;
    158
        mapping(uint256 => string) public policyDocumentURI;
    159
    160
        mapping(uint256 => bool) public eligibilitySet;
    161
        mapping(uint256 => bool) public ratiosSet;
    162
        mapping(uint256 => bool) public concentrationSet;
    163
        mapping(uint256 => bool) public attestationSet;
    164
        mapping(uint256 => bool) public covenantsSet;
    165
        mapping(uint256 => bool) public hasAtLeastOneTier;
    166
    167
        /*//////////////////////////////////////////////////////////////
    168
                                    EVENTS
    169
        //////////////////////////////////////////////////////////////*/
    170
        event PolicyCreated(uint256 version, uint256 timestamp);
    171
        event PolicyFrozen(uint256 version, uint256 timestamp);
    172
        event PolicyEligibilityUpdated(uint256 version, uint256 timestamp);
    173
        event PolicyRatiosUpdated(uint256 version, uint256 timestamp);
    174
        event PolicyConcentrationUpdated(uint256 version, uint256 timestamp);
    175
        event PolicyAttestationUpdated(uint256 version, uint256 timestamp);
    176
        event PolicyCovenantsUpdated(uint256 version, uint256 timestamp);
    177
        event LoanTierUpdated(uint256 version, uint8 tierId, uint256 timestamp);
    178
        event IndustryExcluded(
    179
            uint256 version,
    180
            bytes32 industry,
    181
            uint256 timestamp
    182
        );
    183
        event MaxTiersChanged(uint8 maxTiers);
    184
        event IndustryIncluded(
    185
            uint256 version,
    186
            bytes32 industry,
    187
            uint256 timestamp
    188
        );
    189
    190
        event PolicyAdminChanged(address newAdmin);
    191
    192
        event PolicyDocumentSet(
    193
            uint256 version,
    194
            bytes32 hash,
    195
            string uri,
    196
            uint256 timestamp
    197
        );
    198
        event PolicyDeactivated(uint256 version, uint256 timestamp);
    199
    200
        /*//////////////////////////////////////////////////////////////
    201
                                    CONSTRUCTOR
    202
        //////////////////////////////////////////////////////////////*/
    203
        constructor() {
    204
            policyAdmin = msg.sender;
    205
        }
    206
    207
        /*//////////////////////////////////////////////////////////////
    208
                            POLICY CREATION
    209
        //////////////////////////////////////////////////////////////*/
    210
    211
        function createPolicy(uint256 version) external onlyAdmin {
    212
            if (version == 0) {
    213
                revert CreditPolicy__InvalidVersion();
    214
            }
    215
            if (policyCreated[version]) {
    216
                revert CreditPolicy__PolicyVersionExists(version);
    217
            }
    218
    219
            policyCreated[version] = true;
    220
            policyActive[version] = true;
    221
            lastUpdated[version] = block.timestamp;
    222
            emit PolicyCreated(version, block.timestamp);
    223
        }
    224
    225
        function freezePolicy(
    226
            uint256 version
    227
        ) external onlyAdmin policyExists(version) {
    228
            if (policyFrozen[version]) {
    229
                revert CreditPolicy__PolicyFrozen(version);
    230
            }
    231
            if (policyActive[version] == false) {
    232
                revert CreditPolicy__PolicyNotActive(version);
    233
            }
    234
            if (
    235
                !eligibilitySet[version] ||
    236
                !ratiosSet[version] ||
    237
                !concentrationSet[version] ||
    238
                !attestationSet[version] ||
    239
                !covenantsSet[version] ||
    240
                !hasAtLeastOneTier[version]
    241
            ) {
    242
                revert CreditPolicy__IncompletePolicy(version);
    243
            }
    244
            if (policyDocumentHash[version] == bytes32(0)) {
    245
                revert CreditPolicy__IncompletePolicy(version);
    246
            }
    247
    248
            policyFrozen[version] = true;
    249
            lastUpdated[version] = block.timestamp;
    250
            emit PolicyFrozen(version, block.timestamp);
    251
        }
    252
    253
        function deActivatePolicy(
    254
            uint256 version
    255
        ) external onlyAdmin policyExists(version) {
    256
            policyActive[version] = false;
    257
            lastUpdated[version] = block.timestamp;
    258
            emit PolicyDeactivated(version, block.timestamp);
    259
        }
    260
    261
        /*//////////////////////////////////////////////////////////////
    262
                            ELIGIBILITY UPDATE
    263
        //////////////////////////////////////////////////////////////*/
    264
        function updateEligibility(
    265
            uint256 version,
    266
            EligibilityCriteria calldata data
    267
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    268
            eligibility[version] = data;
    269
            lastUpdated[version] = block.timestamp;
    270
            eligibilitySet[version] = true;
    271
            emit PolicyEligibilityUpdated(version, block.timestamp);
    272
        }
    273
    274
        /*//////////////////////////////////////////////////////////////
    275
                            RATIOS UPDATE
    276
        //////////////////////////////////////////////////////////////*/
    277
        function updateRatios(
    278
            uint256 version,
    279
            FinancialRatios calldata data
    280
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    281
            ratios[version] = data;
    282
            lastUpdated[version] = block.timestamp;
    283
            ratiosSet[version] = true;
    284
            emit PolicyRatiosUpdated(version, block.timestamp);
    285
        }
    286
    287
        /*//////////////////////////////////////////////////////////////
    288
                            CONCENTRATION UPDATE
    289
        //////////////////////////////////////////////////////////////*/
    290
        function updateConcentration(
    291
            uint256 version,
    292
            ConcentrationLimits calldata data
    293
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    294
            concentration[version] = data;
    295
            lastUpdated[version] = block.timestamp;
    296
            concentrationSet[version] = true;
    297
            emit PolicyConcentrationUpdated(version, block.timestamp);
    298
        }
    299
    300
        /*//////////////////////////////////////////////////////////////
    301
                            ATTESTATION UPDATE
    302
        //////////////////////////////////////////////////////////////*/
    303
        function updateAttestation(
    304
            uint256 version,
    305
            AttestationRequirements calldata data
    306
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    307
            attestation[version] = data;
    308
            lastUpdated[version] = block.timestamp;
    309
            attestationSet[version] = true;
    310
            emit PolicyAttestationUpdated(version, block.timestamp);
    311
        }
    312
    313
        /*//////////////////////////////////////////////////////////////
    314
                            COVENANT UPDATE
    315
        //////////////////////////////////////////////////////////////*/
    316
        function updateCovenants(
    317
            uint256 version,
    318
            MaintenanceCovenants calldata data
    319
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    320
            covenants[version] = data;
    321
            lastUpdated[version] = block.timestamp;
    322
            covenantsSet[version] = true;
    323
            emit PolicyCovenantsUpdated(version, block.timestamp);
    324
        }
    325
    326
        /*//////////////////////////////////////////////////////////////
    327
                            LOAN TIERS
    328
        //////////////////////////////////////////////////////////////*/
    329
        function setLoanTier(
    330
            uint256 version,
    331
            uint8 tierId,
    332
            LoanTier calldata tier
    333
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    334
            if (tierId >= maxTiers) {
    335
                revert CreditPolicy__InvalidTierCount(tierId);
    336
            }
    337
            loanTiers[version][tierId] = tier;
    338
            tierExists[version][tierId] = true;
    339
            if (tierId >= totalTiers[version]) {
    340
                totalTiers[version] = tierId + 1;
    341
            }
    342
            hasAtLeastOneTier[version] = true;
    343
            lastUpdated[version] = block.timestamp;
    344
            emit LoanTierUpdated(version, tierId, block.timestamp);
    345
        }
    346
    347
        /*//////////////////////////////////////////////////////////////
    348
                            INDUSTRY CONTROLS
    349
        //////////////////////////////////////////////////////////////*/
    350
        function excludeIndustry(
    351
            uint256 version,
    352
            bytes32 industry
    353
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    354
            if (industry == bytes32(0)) {
    355
                revert CreditPolicy__InvalidIndustryHash();
    356
            }
    357
            excludedIndustries[version][industry] = true;
    358
            lastUpdated[version] = block.timestamp;
    359
            emit IndustryExcluded(version, industry, block.timestamp);
    360
        }
    361
    362
        function includeIndustry(
    363
            uint256 version,
    364
            bytes32 industry
    365
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    366
            if (industry == bytes32(0)) {
    367
                revert CreditPolicy__InvalidIndustryHash();
    368
            }
    369
            excludedIndustries[version][industry] = false;
    370
            lastUpdated[version] = block.timestamp;
    371
            emit IndustryIncluded(version, industry, block.timestamp);
    372
        }
    373
    374
        /*//////////////////////////////////////////////////////////////
    375
                            DOCUMENT UPDATE
    376
        //////////////////////////////////////////////////////////////*/
    377
        function setPolicyDocument(
    378
            uint256 version,
    379
            bytes32 hash,
    380
            string calldata uri
    381
        ) external onlyAdmin policyExists(version) policyEditable(version) {
    382
            policyDocumentHash[version] = hash;
    383
            policyDocumentURI[version] = uri;
    384
            lastUpdated[version] = block.timestamp;
    385
    386
            emit PolicyDocumentSet(version, hash, uri, block.timestamp);
    387
        }
    388
    389
        function changePolicyAdmin(address newAdmin) external onlyAdmin {
    390
            if (newAdmin == address(0)) {
    391
                revert CreditPolicy__InvalidAdmin();
    392
            }
    393
            policyAdmin = newAdmin;
    394
    395
            emit PolicyAdminChanged(newAdmin);
    396
        }
    397
    398
        // getters for interface compliance
    399
    400
        function isPolicyActive(uint256 version) external view returns (bool) {
    401
            return policyActive[version];
    402
        }
    403
    404
        function isPolicyFrozen(uint256 version) external view returns (bool) {
    405
            return policyFrozen[version];
    406
        }
    407
    408
        function tierExistsInPolicy(
    409
            uint256 version,
    410
            uint8 tierId
    411
        ) external view returns (bool) {
    412
            return tierExists[version][tierId];
    413
        }
    414
    415
        function setMaxTiers(uint8 _maxTiers) external onlyAdmin {
    416
            if (_maxTiers == 255) {
    417
                revert CreditPolicy__InvalidTierCount(_maxTiers);
    418
            }
    419
            maxTiers = _maxTiers;
    420
            emit MaxTiersChanged(_maxTiers);
    421
        }
    422
    423
        function getMaxTiers() external view returns (uint8) {
    424
            return maxTiers;
    425
        }
    426
    427
        function isIndustryExcluded(
    428
            uint256 version,
    429
            bytes32 industry
    430
        ) external view returns (bool) {
    431
            return excludedIndustries[version][industry];
    432
        }
    433
    }
    434
    8.0% src/LoanEngine.sol
    Lines covered: 12 / 137 (8.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    4
    import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
    5
    import {ICreditPolicy} from "./interfaces/ICreditPolicy.sol";
    6
    import {IVerifier} from "./interfaces/IVerifier.sol";
    7
    import {ITranchePool} from "./interfaces/ITranchePool.sol";
    8
    import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
    9
    import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    10
    import {TranchePool} from "./TranchePool.sol";
    11
    12
    contract LoanEngine is Ownable, ReentrancyGuard {
    13
        using SafeERC20 for IERC20;
    14
        /*//////////////////////////////////////////////////////////////
    15
                            ERRORS
    16
        //////////////////////////////////////////////////////////////*/
    17
    18
        error LoanEngine__PolicyNotFrozen(uint256 policyVersion);
    19
        error LoanEngine__InvalidProof();
    20
        error LoanEngine__LoanTierIsNotInPolicy(
    21
            uint256 policyVersion,
    22
            uint8 tierId
    23
        );
    24
        error LoanEngine__InvalidLoanParameters(
    25
            uint256 loanId,
    26
            uint256 principalIssued,
    27
            uint256 aprBps,
    28
            uint256 termDays
    29
        );
    30
        error LoanEngine__MaxOriginationFeeExceeded(
    31
            uint256 loanId,
    32
            uint256 originationFeeBps,
    33
            uint256 maxOriginationFeeBps
    34
        );
    35
        error LoanEngine__PoolNotDeployed();
    36
        error LoanEngine__InvalidOffRampingEntity(address entity);
    37
        error LoanEngine__LoanExists(uint256 loanId);
    38
        error LoanEngine__LoanIsNotInCreatedState(uint256 loanId);
    39
        error LoanEngine__LoanIsNotActive(uint256 loanId);
    40
        error LoanEngine__LoanIsNotDefaulted(uint256 loanId);
    41
        error LoanEngine__InvalidRepayment();
    42
        error LoanEngine__ZeroRecovery();
    43
        error LoanEngine__LoanNotRecoverable(uint256 loanId);
    44
        error LoanEngine__ZeroLossOnWriteOff(uint256 loanId);
    45
        error LoanEngine__InvalidFeeManagerEntity(address manager);
    46
        error LoanEngine__InvalidRecoveryAgent(address agent);
    47
        error LoanEngine__InvalidRepaymentAgent(address agent);
    48
        error LoanEngine__InsufficientPoolLiquidity();
    49
        error LoanEngine__ProofAlreadyUsed();
    50
        modifier isWhiteListedOffRampingEntity(address entity) {
    51
            _isWhiteListedOffRampingEntity(entity);
    52
            _;
    53
        }
    54
    55
        function _isWhiteListedOffRampingEntity(address entity) internal view {
    56
            if (!whitelistedOffRampingEntities[entity]) {
    57
                revert LoanEngine__InvalidOffRampingEntity(entity);
    58
            }
    59
        }
    60
    61
        modifier isWhiteListedRecoveryAgent(address agent) {
    62
            _isWhiteListedRecoveryAgent(agent);
    63
            _;
    64
        }
    65
    66
        function _isWhiteListedRecoveryAgent(address agent) internal view {
    67
            if (!whitelistedRecoveryAgents[agent]) {
    68
                revert LoanEngine__InvalidRecoveryAgent(agent);
    69
            }
    70
        }
    71
    72
        modifier isWhiteListedRepaymentAgent(address agent) {
    73
            _isWhiteListedRepaymentAgent(agent);
    74
            _;
    75
        }
    76
    77
        function _isWhiteListedRepaymentAgent(address agent) internal view {
    78
            if (!whitelistedRepaymentAgents[agent]) {
    79
                revert LoanEngine__InvalidRepaymentAgent(agent);
    80
            }
    81
        }
    82
    83
        modifier isWhiteListedFeeManager(address manager) {
    84
            _isWhiteListedFeeManager(manager);
    85
            _;
    86
        }
    87
    88
        function _isWhiteListedFeeManager(address manager) internal view {
    89
            if (!whitelistedFeeManagers[manager]) {
    90
                revert LoanEngine__InvalidFeeManagerEntity(manager);
    91
            }
    92
        }
    93
    94
        ICreditPolicy public creditPolicyContract;
    95
        IVerifier loanProofVerifier;
    96
        ITranchePool tranchePool;
    97
    98
        mapping(uint256 loanId => Loan) public s_loans;
    99
        mapping(uint256 loanId => uint256) public s_originationFees;
    100
        mapping(address whitelistedOffRampingEntity => bool)
    101
            public whitelistedOffRampingEntities;
    102
        mapping(address whiteListedRecoveryAgent => bool)
    103
            public whitelistedRecoveryAgents;
    104
    105
        mapping(address whiteListedRepaymentAgent => bool)
    106
            public whitelistedRepaymentAgents;
    107
    108
        mapping(address whiteListedFeeManager => bool)
    109
            public whitelistedFeeManagers;
    110
        mapping(bytes32 nullifierHash => bool) public s_nullifierHashes;
    111
        uint256 public s_nextLoanId = 1;
    112
        uint256 public s_maxOriginationFeeBps;
    113
        address public s_stableCoinAddress;
    114
        uint256 public constant STANDARD_BPS = 100;
    115
        enum LoanState {
    116
            NONE,
    117
            CREATED,
    118
            ACTIVE,
    119
            REPAID,
    120
            DEFAULTED,
    121
            WRITTEN_OFF
    122
        }
    123
    124
        struct Loan {
    125
            // Identity
    126
            uint256 loanId;
    127
            bytes32 borrowerCommitment;
    128
            uint256 policyVersion;
    129
            uint8 tierId;
    130
            // Economics
    131
            uint256 principalIssued;
    132
            uint256 principalOutstanding;
    133
            uint256 aprBps;
    134
            uint256 originationFeeBps;
    135
            // Interest accounting
    136
            uint256 interestAccrued;
    137
            uint256 interestPaid;
    138
            uint256 lastAccrualTimestamp;
    139
            // Timing
    140
            uint256 startTimestamp;
    141
            uint256 maturityTimestamp;
    142
            uint256 termDays;
    143
            // State
    144
            LoanState state;
    145
            uint256 totalRecovered;
    146
            // allocation_ratio
    147
            uint256 seniorPrincipalAllocated;
    148
            uint256 juniorPrincipalAllocated;
    149
        }
    150
    151
        /*//////////////////////////////////////////////////////////////
    152
                            EVENTS
    153
        //////////////////////////////////////////////////////////////*/
    154
    155
        event LoanCreated(
    156
            uint256 indexed loanId,
    157
            bytes32 borrowerCommitment,
    158
            uint256 principalIssued,
    159
            uint8 tierId,
    160
            uint256 timestamp
    161
        );
    162
    163
        event LoanActivated(
    164
            uint256 indexed loanId,
    165
            uint256 principalIssued,
    166
            uint256 timestamp,
    167
            uint256 startTimestamp,
    168
            uint256 maturityTimestamp
    169
        );
    170
    171
        event LoanRepaid(
    172
            uint256 indexed loanId,
    173
            uint256 principalRepaid,
    174
            uint256 interestRepaid,
    175
            uint256 timestamp
    176
        );
    177
    178
        event LoanClosed(uint256 indexed loanId, uint256 timestamp);
    179
    180
        event LoanDefaulted(
    181
            uint256 indexed loanId,
    182
            bytes32 reasonHash,
    183
            uint256 timestamp
    184
        );
    185
    186
        event LoanWrittenOff(uint256 indexed loanId, uint256 timestamp);
    187
    188
        event LoanRecovered(
    189
            uint256 indexed loanId,
    190
            uint256 amount,
    191
            uint256 timestamp
    192
        );
    193
    194
        constructor(
    195
            address _creditPolicyContract,
    196
            address _loanProofVerifier,
    197
            uint256 _maxOriginationFeeBps,
    198
            address _tranchePool,
    199
            address _stableCoinAddress
    200
        ) Ownable(msg.sender) {
    201
            creditPolicyContract = ICreditPolicy(_creditPolicyContract);
    202
            loanProofVerifier = IVerifier(_loanProofVerifier);
    203
            s_maxOriginationFeeBps = _maxOriginationFeeBps;
    204
            tranchePool = ITranchePool(_tranchePool);
    205
            s_stableCoinAddress = _stableCoinAddress;
    206
        }
    207
    208
        // A notarization step that records a policy-compliant loan intent on-chain
    209
        // TODO: public inputs needed to be verified against the contract state
    210
        // will be implemented after the public inputs structure is finalized
    211
        // preconditions
    212
        // borrowerCommitment should match the publicinput commitment
    213
        // all the parameteres should match the public inputs
    214
        function createLoan(
    215
            bytes32 borrowerCommitment,
    216
            bytes32 nullifierHash,
    217
            uint256 policyVersion,
    218
            uint8 tierId,
    219
            uint256 principalIssued,
    220
            uint256 aprBps,
    221
            uint256 originationFeeBps,
    222
            uint256 termDays,
    223
            bytes32 industry,
    224
            bytes calldata proofData,
    225
            bytes32[] calldata publicInputs
    226
        ) external onlyOwner {
    227
            if (s_loans[s_nextLoanId].state != LoanState.NONE) {
    228
                revert LoanEngine__LoanExists(s_nextLoanId);
    229
            }
    230
            // Implementation goes here
    231
            if (!creditPolicyContract.isPolicyFrozen(policyVersion)) {
    232
                revert LoanEngine__PolicyNotFrozen(policyVersion);
    233
            }
    234
    235
            if (creditPolicyContract.isIndustryExcluded(policyVersion, industry)) {
    236
                revert LoanEngine__PolicyNotFrozen(policyVersion);
    237
            }
    238
    239
            if (!creditPolicyContract.tierExistsInPolicy(policyVersion, tierId)) {
    240
                revert LoanEngine__LoanTierIsNotInPolicy(policyVersion, tierId);
    241
            }
    242
    243
            if (s_nullifierHashes[nullifierHash]) {
    244
                revert LoanEngine__ProofAlreadyUsed();
    245
            }
    246
    247
            if (loanProofVerifier.verify(proofData, publicInputs) == false) {
    248
                revert LoanEngine__InvalidProof();
    249
            }
    250
    251
            if (
    252
                tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED &&
    253
                tranchePool.getPoolState() != TranchePool.PoolState.COMMITED
    254
            ) {
    255
                revert LoanEngine__PoolNotDeployed();
    256
            }
    257
    258
            if (principalIssued == 0 || aprBps == 0 || termDays == 0) {
    259
                revert LoanEngine__InvalidLoanParameters(
    260
                    s_nextLoanId,
    261
                    principalIssued,
    262
                    aprBps,
    263
                    termDays
    264
                );
    265
            }
    266
    267
            if (originationFeeBps > s_maxOriginationFeeBps) {
    268
                revert LoanEngine__MaxOriginationFeeExceeded(
    269
                    s_nextLoanId,
    270
                    originationFeeBps,
    271
                    s_maxOriginationFeeBps
    272
                );
    273
            }
    274
    275
            if (principalIssued > tranchePool.getTotalIdleValue()) {
    276
                revert LoanEngine__InsufficientPoolLiquidity();
    277
            }
    278
    279
            Loan memory newLoan = Loan({
    280
                loanId: s_nextLoanId,
    281
                borrowerCommitment: borrowerCommitment,
    282
                policyVersion: policyVersion,
    283
                tierId: tierId,
    284
                principalIssued: principalIssued,
    285
                principalOutstanding: 0,
    286
                aprBps: aprBps,
    287
                originationFeeBps: originationFeeBps,
    288
                interestAccrued: 0,
    289
                interestPaid: 0,
    290
                lastAccrualTimestamp: 0,
    291
                startTimestamp: 0,
    292
                maturityTimestamp: 0,
    293
                termDays: termDays,
    294
                state: LoanState.CREATED,
    295
                totalRecovered: 0,
    296
                seniorPrincipalAllocated: 0,
    297
                juniorPrincipalAllocated: 0
    298
            });
    299
    300
            s_loans[s_nextLoanId++] = newLoan;
    301
            s_nullifierHashes[nullifierHash] = true;
    302
    303
            emit LoanCreated(
    304
                newLoan.loanId,
    305
                borrowerCommitment,
    306
                principalIssued,
    307
                tierId,
    308
                block.timestamp
    309
            );
    310
        }
    311
    312
        /*
    313
            preconditions
    314
            - onlyOwner
    315
            - loan must already exist
    316
            - loan.state == CREATED
    317
        */
    318
        function activateLoan(
    319
            uint256 loanId,
    320
            address receivingEntity,
    321
            address feeManager
    322
        )
    323
            external
    324
            onlyOwner
    325
            isWhiteListedOffRampingEntity(receivingEntity)
    326
            isWhiteListedFeeManager(feeManager)
    327
            nonReentrant
    328
        {
    329
            // Implementation goes here
    330
            Loan storage loan = s_loans[loanId];
    331
    332
            if (loan.state != LoanState.CREATED) {
    333
                revert LoanEngine__LoanIsNotInCreatedState(loanId);
    334
            }
    335
            loan.principalOutstanding = loan.principalIssued;
    336
            loan.lastAccrualTimestamp = block.timestamp;
    337
            loan.startTimestamp = block.timestamp;
    338
            loan.maturityTimestamp = block.timestamp + (loan.termDays * 1 days);
    339
            loan.state = LoanState.ACTIVE;
    340
    341
            uint256 originationFee = (loan.principalIssued *
    342
                loan.originationFeeBps) / 10000;
    343
    344
            s_originationFees[loanId] = originationFee;
    345
    346
            if (loan.principalIssued > tranchePool.getTotalIdleValue()) {
    347
                revert LoanEngine__InsufficientPoolLiquidity();
    348
            }
    349
    350
            uint256 totalDisbursement = loan.principalIssued - originationFee;
    351
            (uint256 seniorAmount, uint256 juniorAmount, ) = tranchePool
    352
                .allocateCapital(
    353
                    totalDisbursement,
    354
                    originationFee,
    355
                    receivingEntity,
    356
                    feeManager
    357
                );
    358
            loan.seniorPrincipalAllocated = seniorAmount;
    359
    360
            loan.juniorPrincipalAllocated = juniorAmount;
    361
    362
            emit LoanActivated(
    363
                loan.loanId,
    364
                loan.principalIssued,
    365
                block.timestamp,
    366
                loan.startTimestamp,
    367
                loan.maturityTimestamp
    368
            );
    369
        }
    370
    371
        function repayLoan(
    372
            uint256 loanId,
    373
            uint256 principalAmount,
    374
            uint256 interestAmount,
    375
            address repaymentAgent
    376
        )
    377
            external
    378
            onlyOwner
    379
            isWhiteListedRepaymentAgent(repaymentAgent)
    380
            nonReentrant
    381
        {
    382
            Loan storage loan = s_loans[loanId];
    383
            if (loan.state != LoanState.ACTIVE) {
    384
                revert LoanEngine__LoanIsNotActive(loanId);
    385
            }
    386
    387
            uint256 totalPayment = principalAmount + interestAmount;
    388
            if (totalPayment == 0) {
    389
                revert LoanEngine__InvalidRepayment();
    390
            }
    391
    392
            _accrueInterest(loanId);
    393
    394
            // 1️⃣ Transfer funds to pool (settlement layer)
    395
            IERC20(s_stableCoinAddress).safeTransferFrom(
    396
                repaymentAgent,
    397
                address(tranchePool),
    398
                totalPayment
    399
            );
    400
    401
            // 2️⃣ Interest first
    402
            uint256 interestDue = loan.interestAccrued;
    403
            uint256 interestPaid = totalPayment > interestDue
    404
                ? interestDue
    405
                : totalPayment;
    406
    407
            // 3️⃣ Principal second
    408
            uint256 remainingForPrincipal = totalPayment - interestPaid;
    409
            uint256 principalDue = loan.principalOutstanding;
    410
    411
            uint256 principalPaid = remainingForPrincipal > principalDue
    412
                ? principalDue
    413
                : remainingForPrincipal;
    414
    415
            // 4️⃣ Update loan accounting
    416
            loan.interestAccrued -= interestPaid;
    417
            loan.interestPaid += interestPaid;
    418
            loan.principalOutstanding -= principalPaid;
    419
    420
            bool fullyRepaid = loan.principalOutstanding == 0 &&
    421
                loan.interestAccrued == 0;
    422
    423
            if (fullyRepaid) {
    424
                loan.state = LoanState.REPAID;
    425
            }
    426
    427
            tranchePool.onRepayment(principalPaid, interestPaid);
    428
    429
            emit LoanRepaid(
    430
                loan.loanId,
    431
                principalPaid,
    432
                interestPaid,
    433
                block.timestamp
    434
            );
    435
    436
            if (fullyRepaid) {
    437
                emit LoanClosed(loanId, block.timestamp);
    438
            }
    439
        }
    440
    441
        function declareDefault(
    442
            uint256 loanId,
    443
            bytes32 reasonHash
    444
        ) external onlyOwner {
    445
            // Implementation goes here
    446
            Loan storage loan = s_loans[loanId];
    447
            if (loan.state != LoanState.ACTIVE) {
    448
                revert LoanEngine__LoanIsNotActive(loanId);
    449
            }
    450
            _accrueInterest(loanId);
    451
            loan.state = LoanState.DEFAULTED;
    452
            emit LoanDefaulted(loanId, reasonHash, block.timestamp);
    453
        }
    454
    455
        function writeOffLoan(uint256 loanId) external onlyOwner {
    456
            // Implementation goes here
    457
            Loan storage loan = s_loans[loanId];
    458
            if (loan.state != LoanState.DEFAULTED) {
    459
                revert LoanEngine__LoanIsNotDefaulted(loanId);
    460
            }
    461
            uint256 loss = loan.principalOutstanding;
    462
            uint256 interestAccrued = loan.interestAccrued;
    463
            if (loss == 0) {
    464
                revert LoanEngine__ZeroLossOnWriteOff(loanId);
    465
            }
    466
    467
            loan.principalOutstanding = 0;
    468
            loan.interestAccrued = 0;
    469
            loan.state = LoanState.WRITTEN_OFF;
    470
            tranchePool.onLoss(loss, interestAccrued);
    471
            emit LoanWrittenOff(loanId, block.timestamp);
    472
        }
    473
    474
        function recoverLoan(
    475
            uint256 loanId,
    476
            uint256 amount,
    477
            address recoveryAgent
    478
        ) external onlyOwner isWhiteListedRecoveryAgent(recoveryAgent) {
    479
            Loan storage loan = s_loans[loanId];
    480
            if (loan.state != LoanState.WRITTEN_OFF) {
    481
                revert LoanEngine__LoanNotRecoverable(loanId);
    482
            }
    483
            if (amount == 0) {
    484
                revert LoanEngine__ZeroRecovery();
    485
            }
    486
            loan.totalRecovered += amount;
    487
            IERC20(s_stableCoinAddress).safeTransferFrom(
    488
                recoveryAgent,
    489
                address(tranchePool),
    490
                amount
    491
            );
    492
            tranchePool.onRecovery(amount);
    493
            emit LoanRecovered(loanId, amount, block.timestamp);
    494
        }
    495
    496
        function _accrueInterest(uint256 loanId) internal {
    497
            // Implementation goes here
    498
            Loan storage loan = s_loans[loanId];
    499
            if (loan.state != LoanState.ACTIVE) {
    500
                revert LoanEngine__LoanIsNotActive(loanId);
    501
            }
    502
            uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp;
    503
            if (loan.principalOutstanding == 0) {
    504
                loan.lastAccrualTimestamp = block.timestamp;
    505
                return;
    506
            }
    507
    508
            uint256 interest = (loan.principalOutstanding *
    509
                loan.aprBps *
    510
                timeElapsed) / (365 days * 10_000);
    511
    512
            if (interest > 0) {
    513
                loan.interestAccrued += interest;
    514
                uint256 totalAllocated = loan.principalIssued;
    515
                uint256 seniorInterest = (interest *
    516
                    loan.seniorPrincipalAllocated) / totalAllocated;
    517
    518
                uint256 juniorInterest = (interest *
    519
                    loan.juniorPrincipalAllocated) / totalAllocated;
    520
                tranchePool.onInterestAccrued(
    521
                    interest,
    522
                    seniorInterest,
    523
                    juniorInterest
    524
                );
    525
            }
    526
            loan.lastAccrualTimestamp = block.timestamp;
    527
        }
    528
    529
        // setters for contract management
    530
    531
        function setMaxOriginationFeeBps(
    532
            uint256 _maxOriginationFeeBps
    533
        ) external onlyOwner {
    534
            s_maxOriginationFeeBps = _maxOriginationFeeBps;
    535
        }
    536
    537
        function setWhitelistedOffRampingEntity(
    538
            address entity,
    539
            bool isWhitelisted
    540
        ) external onlyOwner {
    541
            whitelistedOffRampingEntities[entity] = isWhitelisted;
    542
        }
    543
    544
        function setWhitelistedRecoveryAgent(
    545
            address agent,
    546
            bool isWhitelisted
    547
        ) external onlyOwner {
    548
            whitelistedRecoveryAgents[agent] = isWhitelisted;
    549
        }
    550
    551
        function setWhitelistedRepaymentAgent(
    552
            address agent,
    553
            bool isWhitelisted
    554
        ) external onlyOwner {
    555
            whitelistedRepaymentAgents[agent] = isWhitelisted;
    556
        }
    557
    558
        function setWhitelistedFeeManager(
    559
            address manager,
    560
            bool isWhitelisted
    561
        ) external onlyOwner {
    562
            whitelistedFeeManagers[manager] = isWhitelisted;
    563
        }
    564
    565
        function getMaxOriginationFeeBps() external view returns (uint256) {
    566
            return s_maxOriginationFeeBps;
    567
        }
    568
    569
        function getNextLoanId() external view returns (uint256) {
    570
            return s_nextLoanId;
    571
        }
    572
    573
        function getLoanDetails(
    574
            uint256 loanId
    575
        ) external view returns (Loan memory) {
    576
            return s_loans[loanId];
    577
        }
    578
    }
    579
    11.0% src/TranchePool.sol
    Lines covered: 50 / 443 (11.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    4
    import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
    5
    import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    6
    7
    contract TranchePool is Ownable {
    8
        using SafeERC20 for IERC20;
    9
    10
        // Errors
    11
        error TranchePool__NotWhiteListed(address user);
    12
        error TranchePool__LessThanDepositThreshold(uint256 amount);
    13
        error TranchePool__InvalidAllocationRatio();
    14
        error TranchePool__InsufficientLiquidity();
    15
        error TranchePool__InsufficientShares();
    16
        error TranchePool__ZeroWithdrawal();
    17
        error TranchePool__NotWhiteListedForEquityTranche(address user);
    18
        error TranchePool__InvalidTransferAmount(uint256 amount);
    19
        error TranchePool__InvalidCaller(address user);
    20
        error TranchePool__ZeroAPRError();
    21
        error TranchePool__LossExceededCapital(uint256 remaining);
    22
        error TranchePool__ZeroSharesMinted();
    23
        error TranchePool__PoolIsNotOpen();
    24
        error TranchePool__InvalidStateTransition(PoolState state);
    25
        error TranchePool__WithdrawNotAllowed(PoolState state);
    26
        error TranchePool__ZeroValueError();
    27
        error TranchePool__MaxDepositCapExceeded(uint256 maxCap, uint256 amount);
    28
        error TranchePool__PoolIsNotCommited();
    29
        error TranchePool__PrincipalRepaymentExceeded();
    30
        error TranchePool__ZeroAddressError();
    31
        error TranchePool__DeployedCapitalExists();
    32
        error TranchePool__InvalidMaxCapAmount();
    33
        error TranchePool__InvalidMinDepositAmount();
    34
        // Events
    35
    36
        event PoolStateUpdated(PoolState newState);
    37
    38
        event LossAllocated(
    39
            uint256 seniorLoss,
    40
            uint256 juniorLoss,
    41
            uint256 equityLoss
    42
        );
    43
        event WithdrawnFromSeniorTranche(
    44
            address indexed user,
    45
            uint256 amount,
    46
            uint256 sharesBurned,
    47
            uint256 time
    48
        );
    49
        event WithdrawnFromJuniorTranche(
    50
            address indexed user,
    51
            uint256 amount,
    52
            uint256 sharesBurned,
    53
            uint256 time
    54
        );
    55
        event WithdrawnFromEquityTranche(
    56
            address indexed user,
    57
            uint256 amount,
    58
            uint256 sharesBurned,
    59
            uint256 time
    60
        );
    61
    62
        event FundsDepositedToSeniorTranche(
    63
            address indexed user,
    64
            uint256 amount,
    65
            uint256 shares,
    66
            uint256 time
    67
        );
    68
        event FundsDepositedToJuniorTranche(
    69
            address indexed user,
    70
            uint256 amount,
    71
            uint256 shares,
    72
            uint256 time
    73
        );
    74
        event FundsDepositedToEquityTranche(
    75
            address indexed user,
    76
            uint256 amount,
    77
            uint256 shares,
    78
            uint256 time
    79
        );
    80
        event CapitalAllocated(
    81
            uint256 seniorAmount,
    82
            uint256 juniorAmount,
    83
            uint256 equityAmount,
    84
            uint256 time
    85
        );
    86
        event RecoverAmountTransferredToTranchePool(
    87
            uint256 amount,
    88
            uint256 timeStamp
    89
        );
    90
        event ProfitTransferredToTranchePool(uint256 amount, uint256 timeStamp);
    91
        event CapitalAllocationFactorUpdatedSenior(uint256 newFactor);
    92
        event CapitalAllocationFactorUpdatedJunior(uint256 newFactor);
    93
    94
        enum PoolState {
    95
            OPEN, // deposits allowed
    96
            COMMITED,
    97
            DEPLOYED, // capital deployed, deposits paused
    98
            CLOSED // withdrawals only
    99
        }
    100
    101
        // Whitelist
    102
        mapping(address => bool) public whiteListedLps;
    103
        mapping(address => bool) public whiteListedForEquityTranche;
    104
    105
        // Shares tracking (instead of amounts)
    106
        mapping(address => uint256) public s_seniorTrancheShares;
    107
        mapping(address => uint256) public s_juniorTrancheShares;
    108
        mapping(address => uint256) public s_equityTrancheShares;
    109
    110
        uint256 public s_totalSeniorShares;
    111
        uint256 public s_totalJuniorShares;
    112
        uint256 public s_totalEquityShares;
    113
    114
        // Total value in each tranche (this decreases when capital is allocated)
    115
        // why some part of the capital should stay idle.
    116
        // 1. Liquidity and operational buffer.
    117
        //
    118
        uint256 public s_seniorTrancheIdleValue;
    119
        uint256 public s_juniorTrancheIdleValue;
    120
        uint256 public s_equityTrancheIdleValue;
    121
    122
        uint256 public s_seniorTrancheDeployedValue;
    123
        uint256 public s_juniorTrancheDeployedValue;
    124
        uint256 public s_equityTrancheDeployedValue;
    125
    126
        // Minimum deposits
    127
        uint256 public s_minimumDepositAmountSeniorTranche;
    128
        uint256 public s_minimumDepositAmountJuniorTranche;
    129
        uint256 public s_minimumDepositAmountEquityTranche;
    130
    131
        // CHANGED: global interest index (scaled)
    132
        uint256 public seniorInterestIndex; // 1e18 precision
    133
        uint256 public juniorInterestIndex; // 1e18 precision
    134
        uint256 public equityInterestIndex; // 1e18 precision
    135
    136
        // CHANGED: per-user last claimed index
    137
        mapping(address => uint256) public seniorUserIndex;
    138
        mapping(address => uint256) public juniorUserIndex;
    139
        mapping(address => uint256) public equityUserIndex;
    140
    141
        // Stable coin
    142
        address public s_stableCoin;
    143
        address public loanEngine;
    144
    145
        // Capital allocation factor (e.g., 80 for 80% senior, 15% junior, 5% equity)
    146
        uint256 public s_capital_allocation_factor_senior;
    147
        uint256 public s_capital_allocation_factor_junior;
    148
    149
        uint256 public s_senior_apr;
    150
        uint256 public s_target_junior_apr;
    151
    152
        uint256 public seniorAccruedInterest;
    153
        uint256 public juniorAccruedInterest;
    154
        uint256 public equityAccruedInterest;
    155
    156
        uint256 public s_seniorTrancheMaxCap;
    157
        uint256 public s_juniorTrancheMaxCap;
    158
        uint256 public s_equityTrancheMaxCap;
    159
    160
        uint256 public s_protocolRevenue;
    161
        uint256 public s_totalDeposited;
    162
        uint256 public s_totalLoss;
    163
        uint256 public s_totalRecovered;
    164
    165
        PoolState public poolState = PoolState.OPEN;
    166
    167
        uint256 public seniorPrincipalShortfall;
    168
        uint256 public juniorPrincipalShortfall;
    169
        uint256 public equityPrincipalShortfall;
    170
    171
        modifier isWhiteListed(address user) {
    172
            _isWhiteListed(user);
    173
            _;
    174
        }
    175
    176
        function _isWhiteListed(address user) internal view {
    177
            if (!whiteListedLps[user]) {
    178
                revert TranchePool__NotWhiteListed(user);
    179
            }
    180
        }
    181
    182
        modifier onlyLoanEngine(address user) {
    183
            _onlyLoanEngine(user);
    184
            _;
    185
        }
    186
    187
        function _onlyLoanEngine(address user) internal view {
    188
            if (user != loanEngine) {
    189
                revert TranchePool__InvalidCaller(user);
    190
            }
    191
        }
    192
    193
        modifier isWhiteListedForEquityTranche(address user) {
    194
            _isWhiteListedForEquityTranche(user);
    195
            _;
    196
        }
    197
    198
        function _isWhiteListedForEquityTranche(address user) internal view {
    199
            if (!whiteListedForEquityTranche[user]) {
    200
                revert TranchePool__NotWhiteListedForEquityTranche(user);
    201
            }
    202
        }
    203
    204
        constructor(address stableCoin_) Ownable(msg.sender) {
    205
            s_stableCoin = stableCoin_;
    206
            seniorInterestIndex = 1e18;
    207
            juniorInterestIndex = 1e18;
    208
            equityInterestIndex = 1e18;
    209
        }
    210
    211
        function depositSeniorTranche(
    212
            uint256 amount
    213
        ) external isWhiteListed(msg.sender) {
    214
            // q: wy we need a minimum deposit for a tranche?
    215
            // a: in book.
    216
            if (poolState != PoolState.OPEN) {
    217
                revert TranchePool__PoolIsNotOpen();
    218
            }
    219
            if (amount == 0) {
    220
                revert TranchePool__ZeroValueError();
    221
            }
    222
            if (amount < s_minimumDepositAmountSeniorTranche) {
    223
                revert TranchePool__LessThanDepositThreshold(amount);
    224
            }
    225
            // why there is a max cap exists?
    226
            //
    227
            //  1. to prevent the liquidity from sitting idle
    228
            //
    229
            if (amount + s_seniorTrancheIdleValue > s_seniorTrancheMaxCap) {
    230
                revert TranchePool__MaxDepositCapExceeded(
    231
                    s_seniorTrancheMaxCap,
    232
                    amount
    233
                );
    234
            }
    235
    236
            // Calculate shares to mint
    237
            // invariant: the total shares == idle value because the deposit is allowed only when
    238
            // the pool is open and once the pool is moved to a new state new deposits are not allowed
    239
            // so what shares == amount holding 1:1 is valid and is not affecting or opening any attack vectors.
    240
            uint256 shares = amount;
    241
    242
            IERC20(s_stableCoin).safeTransferFrom(
    243
                msg.sender,
    244
                address(this),
    245
                amount
    246
            );
    247
    248
            s_seniorTrancheShares[msg.sender] += shares;
    249
            s_totalSeniorShares += shares;
    250
            s_seniorTrancheIdleValue += amount;
    251
            seniorUserIndex[msg.sender] = seniorInterestIndex;
    252
            s_totalDeposited += amount;
    253
            emit FundsDepositedToSeniorTranche(
    254
                msg.sender,
    255
                amount,
    256
                shares,
    257
                block.timestamp
    258
            );
    259
        }
    260
    261
        function depositJuniorTranche(
    262
            uint256 amount
    263
        ) external isWhiteListed(msg.sender) {
    264
            if (poolState != PoolState.OPEN) {
    265
                revert TranchePool__PoolIsNotOpen();
    266
            }
    267
            if (amount < s_minimumDepositAmountJuniorTranche) {
    268
                revert TranchePool__LessThanDepositThreshold(amount);
    269
            }
    270
    271
            if (amount + s_juniorTrancheIdleValue > s_juniorTrancheMaxCap) {
    272
                revert TranchePool__MaxDepositCapExceeded(
    273
                    s_juniorTrancheMaxCap,
    274
                    amount
    275
                );
    276
            }
    277
    278
            uint256 shares = amount;
    279
    280
            IERC20(s_stableCoin).safeTransferFrom(
    281
                msg.sender,
    282
                address(this),
    283
                amount
    284
            );
    285
    286
            s_juniorTrancheShares[msg.sender] += shares;
    287
            s_totalJuniorShares += shares;
    288
            s_juniorTrancheIdleValue += amount;
    289
            juniorUserIndex[msg.sender] = juniorInterestIndex;
    290
            s_totalDeposited += amount;
    291
    292
            emit FundsDepositedToJuniorTranche(
    293
                msg.sender,
    294
                amount,
    295
                shares,
    296
                block.timestamp
    297
            );
    298
        }
    299
    300
        function depositEquityTranche(
    301
            uint256 amount
    302
        ) external isWhiteListedForEquityTranche(msg.sender) {
    303
            if (poolState != PoolState.OPEN) {
    304
                revert TranchePool__PoolIsNotOpen();
    305
            }
    306
            if (amount < s_minimumDepositAmountEquityTranche) {
    307
                revert TranchePool__LessThanDepositThreshold(amount);
    308
            }
    309
    310
            if (amount + s_equityTrancheIdleValue > s_equityTrancheMaxCap) {
    311
                revert TranchePool__MaxDepositCapExceeded(
    312
                    s_equityTrancheMaxCap,
    313
                    amount
    314
                );
    315
            }
    316
    317
            uint256 shares = amount;
    318
    319
            IERC20(s_stableCoin).safeTransferFrom(
    320
                msg.sender,
    321
                address(this),
    322
                amount
    323
            );
    324
            s_equityTrancheShares[msg.sender] += shares;
    325
            s_totalEquityShares += shares;
    326
            s_equityTrancheIdleValue += amount;
    327
            equityUserIndex[msg.sender] = equityInterestIndex;
    328
            s_totalDeposited += amount;
    329
    330
            emit FundsDepositedToEquityTranche(
    331
                msg.sender,
    332
                amount,
    333
                shares,
    334
                block.timestamp
    335
            );
    336
        }
    337
    338
        /**
    339
         * @notice Allocate capital according to the 80/20 split
    340
         * @param totalDisbursement Total amount to allocate from the pool
    341
         * @param fees Total fees to be collected
    342
         */
    343
        function allocateCapital(
    344
            uint256 totalDisbursement,
    345
            uint256 fees,
    346
            address deployer,
    347
            address feeManager
    348
        ) external onlyLoanEngine(msg.sender) returns (uint256, uint256, uint256) {
    349
            if (
    350
                poolState != PoolState.COMMITED && poolState != PoolState.DEPLOYED
    351
            ) {
    352
                revert TranchePool__PoolIsNotCommited();
    353
            }
    354
    355
            uint256 totalAmount = totalDisbursement + fees;
    356
    357
            // Global liquidity check
    358
            uint256 totalIdle = s_seniorTrancheIdleValue +
    359
                s_juniorTrancheIdleValue +
    360
                s_equityTrancheIdleValue;
    361
    362
            if (totalAmount > totalIdle) {
    363
                revert TranchePool__InsufficientLiquidity();
    364
            }
    365
    366
            uint256 targetSenior = (totalAmount *
    367
                s_capital_allocation_factor_senior) / 100;
    368
    369
            uint256 targetJunior = (totalAmount *
    370
                s_capital_allocation_factor_junior) / 100;
    371
    372
            uint256 targetEquity = totalAmount - targetSenior - targetJunior;
    373
    374
            uint256 seniorAmount = _minimum(targetSenior, s_seniorTrancheIdleValue);
    375
    376
            uint256 juniorAmount = _minimum(targetJunior, s_juniorTrancheIdleValue);
    377
    378
            uint256 equityAmount = _minimum(targetEquity, s_equityTrancheIdleValue);
    379
    380
            uint256 allocated = seniorAmount + juniorAmount + equityAmount;
    381
    382
            uint256 remaining = totalAmount - allocated;
    383
    384
            // Equity absorbs first
    385
            if (remaining > 0 && s_equityTrancheIdleValue > equityAmount) {
    386
                uint256 extra = _minimum(
    387
                    remaining,
    388
                    s_equityTrancheIdleValue - equityAmount
    389
                );
    390
                equityAmount += extra;
    391
                remaining -= extra;
    392
            }
    393
    394
            // Junior absorbs next
    395
            if (remaining > 0 && s_juniorTrancheIdleValue > juniorAmount) {
    396
                uint256 extra = _minimum(
    397
                    remaining,
    398
                    s_juniorTrancheIdleValue - juniorAmount
    399
                );
    400
                juniorAmount += extra;
    401
                remaining -= extra;
    402
            }
    403
    404
            // Senior absorbs last
    405
            if (remaining > 0 && s_seniorTrancheIdleValue > seniorAmount) {
    406
                uint256 extra = _minimum(
    407
                    remaining,
    408
                    s_seniorTrancheIdleValue - seniorAmount
    409
                );
    410
                seniorAmount += extra;
    411
                remaining -= extra;
    412
            }
    413
    414
            // Final safety check
    415
            if (remaining > 0) {
    416
                revert TranchePool__InsufficientLiquidity();
    417
            }
    418
    419
            if (poolState == PoolState.COMMITED) {
    420
                poolState = PoolState.DEPLOYED;
    421
                emit PoolStateUpdated(PoolState.DEPLOYED);
    422
            }
    423
    424
            s_seniorTrancheIdleValue -= seniorAmount;
    425
            s_juniorTrancheIdleValue -= juniorAmount;
    426
            s_equityTrancheIdleValue -= equityAmount;
    427
    428
            s_seniorTrancheDeployedValue += seniorAmount;
    429
            s_juniorTrancheDeployedValue += juniorAmount;
    430
            s_equityTrancheDeployedValue += equityAmount;
    431
    432
            IERC20(s_stableCoin).safeTransfer(deployer, totalDisbursement);
    433
    434
            if (fees > 0) {
    435
                IERC20(s_stableCoin).safeTransfer(feeManager, fees);
    436
            }
    437
    438
            emit CapitalAllocated(
    439
                seniorAmount,
    440
                juniorAmount,
    441
                equityAmount,
    442
                block.timestamp
    443
            );
    444
            return (seniorAmount, juniorAmount, equityAmount);
    445
        }
    446
    447
        function onInterestAccrued(
    448
            uint256 interestAmount,
    449
            uint256 seniorInterest,
    450
            uint256 juniorInterest
    451
        ) external onlyLoanEngine(msg.sender) {
    452
            if (interestAmount == 0) return;
    453
    454
            seniorAccruedInterest += seniorInterest;
    455
            juniorAccruedInterest += juniorInterest;
    456
            equityAccruedInterest += (interestAmount -
    457
                seniorInterest -
    458
                juniorInterest);
    459
        }
    460
    461
        function onRepayment(
    462
            uint256 principalRepaid,
    463
            uint256 interestRepaid
    464
        ) external onlyLoanEngine(msg.sender) {
    465
            if (principalRepaid == 0 && interestRepaid == 0) {
    466
                revert TranchePool__InvalidTransferAmount(0);
    467
            }
    468
    469
            /*//////////////////////////////////////////////////////////////
    470
                            INTEREST WATERFALL (INDEXED)
    471
        //////////////////////////////////////////////////////////////*/
    472
    473
            uint256 remainingInterest = interestRepaid;
    474
    475
            // 1️⃣ Senior interest
    476
            if (
    477
                remainingInterest > 0 &&
    478
                seniorAccruedInterest > 0 &&
    479
                s_totalSeniorShares > 0
    480
            ) {
    481
                uint256 seniorPaid = _minimum(
    482
                    remainingInterest,
    483
                    seniorAccruedInterest
    484
                );
    485
                seniorAccruedInterest -= seniorPaid;
    486
                seniorInterestIndex += (seniorPaid * 1e18) / s_totalSeniorShares;
    487
                remainingInterest -= seniorPaid;
    488
            }
    489
    490
            // 2️⃣ Junior interest
    491
            if (
    492
                remainingInterest > 0 &&
    493
                juniorAccruedInterest > 0 &&
    494
                s_totalJuniorShares > 0
    495
            ) {
    496
                uint256 juniorPaid = _minimum(
    497
                    remainingInterest,
    498
                    juniorAccruedInterest
    499
                );
    500
                juniorAccruedInterest -= juniorPaid;
    501
                juniorInterestIndex += (juniorPaid * 1e18) / s_totalJuniorShares;
    502
                remainingInterest -= juniorPaid;
    503
            }
    504
    505
            // 3️⃣ Equity / overflow interest
    506
            if (remainingInterest > 0) {
    507
                if (s_totalEquityShares > 0) {
    508
                    equityInterestIndex +=
    509
                        (remainingInterest * 1e18) /
    510
                        s_totalEquityShares;
    511
                    equityAccruedInterest -= _minimum(
    512
                        equityAccruedInterest,
    513
                        remainingInterest
    514
                    );
    515
                } else if (s_totalJuniorShares > 0) {
    516
                    // no equity → junior gets excess
    517
                    juniorInterestIndex +=
    518
                        (remainingInterest * 1e18) /
    519
                        s_totalJuniorShares;
    520
                } else {
    521
                    // no LPs left → protocol revenue
    522
                    s_protocolRevenue += remainingInterest;
    523
                }
    524
            }
    525
    526
            /*//////////////////////////////////////////////////////////////
    527
                            PRINCIPAL REDEMPTION
    528
                (REVERSE OF LOSS WATERFALL — NO RATIOS)
    529
        //////////////////////////////////////////////////////////////*/
    530
    531
            if (principalRepaid > 0) {
    532
                uint256 remaining = principalRepaid;
    533
    534
                // Senior first (restore safest capital)
    535
                if (remaining > 0 && s_seniorTrancheDeployedValue > 0) {
    536
                    uint256 seniorPay = _minimum(
    537
                        remaining,
    538
                        s_seniorTrancheDeployedValue
    539
                    );
    540
                    s_seniorTrancheDeployedValue -= seniorPay;
    541
                    s_seniorTrancheIdleValue += seniorPay;
    542
                    remaining -= seniorPay;
    543
                }
    544
    545
                // Junior next
    546
                if (remaining > 0 && s_juniorTrancheDeployedValue > 0) {
    547
                    uint256 juniorPay = _minimum(
    548
                        remaining,
    549
                        s_juniorTrancheDeployedValue
    550
                    );
    551
                    s_juniorTrancheDeployedValue -= juniorPay;
    552
                    s_juniorTrancheIdleValue += juniorPay;
    553
                    remaining -= juniorPay;
    554
                }
    555
    556
                // Equity last
    557
                if (remaining > 0 && s_equityTrancheDeployedValue > 0) {
    558
                    uint256 equityPay = _minimum(
    559
                        remaining,
    560
                        s_equityTrancheDeployedValue
    561
                    );
    562
                    s_equityTrancheDeployedValue -= equityPay;
    563
                    s_equityTrancheIdleValue += equityPay;
    564
                    remaining -= equityPay;
    565
                }
    566
    567
                // Safety: should never happen unless LoanEngine lies
    568
                if (remaining > 0) {
    569
                    revert TranchePool__PrincipalRepaymentExceeded();
    570
                }
    571
            }
    572
        }
    573
    574
        // lp profit withdrawal is pending but it can only be implemented
    575
        // after the loan enginge implementation which determines how the
    576
        // interest will be accured and the distribution is dependent on the
    577
        // share capacity
    578
    579
        function onLoss(
    580
            uint256 principalLoss,
    581
            uint256 interestAccrued
    582
        ) external onlyLoanEngine(msg.sender) {
    583
            if (principalLoss == 0 && interestAccrued == 0) {
    584
                revert TranchePool__ZeroValueError();
    585
            }
    586
    587
            /*//////////////////////////////////////////////////////////////
    588
                        1️⃣ CANCEL GHOST INTEREST
    589
            (SAME PRIORITY AS INTEREST PAYOUT)
    590
        //////////////////////////////////////////////////////////////*/
    591
    592
            uint256 remainingInterest = interestAccrued;
    593
    594
            // Cancel senior accrued interest first
    595
            if (remainingInterest > 0 && seniorAccruedInterest > 0) {
    596
                uint256 seniorCancel = _minimum(
    597
                    remainingInterest,
    598
                    seniorAccruedInterest
    599
                );
    600
                seniorAccruedInterest -= seniorCancel;
    601
                remainingInterest -= seniorCancel;
    602
            }
    603
    604
            // Then junior
    605
            if (remainingInterest > 0 && juniorAccruedInterest > 0) {
    606
                uint256 juniorCancel = _minimum(
    607
                    remainingInterest,
    608
                    juniorAccruedInterest
    609
                );
    610
                juniorAccruedInterest -= juniorCancel;
    611
                remainingInterest -= juniorCancel;
    612
            }
    613
    614
            // Any remaining interest is ignored (equity / protocol had no promise)
    615
    616
            /*//////////////////////////////////////////////////////////////
    617
                        2️⃣ PRINCIPAL LOSS WATERFALL
    618
                    Equity → Junior → Senior
    619
        //////////////////////////////////////////////////////////////*/
    620
    621
            s_totalLoss += principalLoss;
    622
            uint256 remaining = principalLoss;
    623
    624
            uint256 equityLoss;
    625
            uint256 juniorLoss;
    626
            uint256 seniorLoss;
    627
    628
            // Equity absorbs first
    629
            if (remaining > 0 && s_equityTrancheDeployedValue > 0) {
    630
                equityLoss = _minimum(remaining, s_equityTrancheDeployedValue);
    631
                s_equityTrancheDeployedValue -= equityLoss;
    632
                equityPrincipalShortfall += equityLoss;
    633
                remaining -= equityLoss;
    634
            }
    635
    636
            // Junior next
    637
            if (remaining > 0 && s_juniorTrancheDeployedValue > 0) {
    638
                juniorLoss = _minimum(remaining, s_juniorTrancheDeployedValue);
    639
                s_juniorTrancheDeployedValue -= juniorLoss;
    640
                juniorPrincipalShortfall += juniorLoss;
    641
                remaining -= juniorLoss;
    642
            }
    643
    644
            // Senior last
    645
            if (remaining > 0 && s_seniorTrancheDeployedValue > 0) {
    646
                seniorLoss = _minimum(remaining, s_seniorTrancheDeployedValue);
    647
                s_seniorTrancheDeployedValue -= seniorLoss;
    648
                seniorPrincipalShortfall += seniorLoss;
    649
                remaining -= seniorLoss;
    650
            }
    651
    652
            if (remaining > 0) {
    653
                revert TranchePool__LossExceededCapital(remaining);
    654
            }
    655
    656
            emit LossAllocated(seniorLoss, juniorLoss, equityLoss);
    657
        }
    658
    659
        // on recovery what happens is the protocol may recover more than he lost and it can cause appreciation of the share value when withdrawing, keeping the design simple because adding it to interest accured make no difference at the end of withdrawing.
    660
    661
        function onRecovery(uint256 amount) external onlyLoanEngine(msg.sender) {
    662
            if (amount == 0) {
    663
                revert TranchePool__ZeroValueError();
    664
            }
    665
    666
            s_totalRecovered += amount;
    667
            uint256 remaining = amount;
    668
    669
            // Senior first
    670
            if (remaining > 0 && seniorPrincipalShortfall > 0) {
    671
                uint256 seniorPay = _minimum(remaining, seniorPrincipalShortfall);
    672
                seniorPrincipalShortfall -= seniorPay;
    673
                s_seniorTrancheIdleValue += seniorPay;
    674
                remaining -= seniorPay;
    675
            }
    676
    677
            // Junior next
    678
            if (remaining > 0 && juniorPrincipalShortfall > 0) {
    679
                uint256 juniorPay = _minimum(remaining, juniorPrincipalShortfall);
    680
                juniorPrincipalShortfall -= juniorPay;
    681
                s_juniorTrancheIdleValue += juniorPay;
    682
                remaining -= juniorPay;
    683
            }
    684
    685
            // Equity last
    686
            if (remaining > 0 && equityPrincipalShortfall > 0) {
    687
                uint256 equityPay = _minimum(remaining, equityPrincipalShortfall);
    688
                equityPrincipalShortfall -= equityPay;
    689
                s_equityTrancheIdleValue += equityPay;
    690
                remaining -= equityPay;
    691
            }
    692
    693
            // Any excess is true upside → equity
    694
            if (remaining > 0) {
    695
                s_equityTrancheIdleValue += remaining;
    696
            }
    697
    698
            emit RecoverAmountTransferredToTranchePool(amount, block.timestamp);
    699
        }
    700
    701
        // when the pool closes if the user withdraw the shares before claiming interest on those he will lose the interest for the withdrawn shares
    702
        function claimSeniorInterest() external {
    703
            uint256 userShares = s_seniorTrancheShares[msg.sender];
    704
            if (userShares == 0) revert TranchePool__InsufficientShares();
    705
    706
            uint256 indexDelta = seniorInterestIndex - seniorUserIndex[msg.sender];
    707
    708
            if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();
    709
    710
            uint256 claimable = (userShares * indexDelta) / 1e18;
    711
    712
            // CHANGED: update user index BEFORE transfer
    713
            seniorUserIndex[msg.sender] = seniorInterestIndex;
    714
    715
            IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    716
        }
    717
    718
        function claimJuniorInterest() external {
    719
            uint256 userShares = s_juniorTrancheShares[msg.sender];
    720
            if (userShares == 0) revert TranchePool__InsufficientShares();
    721
    722
            uint256 indexDelta = juniorInterestIndex - juniorUserIndex[msg.sender];
    723
    724
            if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();
    725
    726
            uint256 claimable = (userShares * indexDelta) / 1e18;
    727
    728
            // CHANGED: update user index BEFORE transfer
    729
            juniorUserIndex[msg.sender] = juniorInterestIndex;
    730
    731
            IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    732
        }
    733
    734
        function claimEquityInterest()
    735
            external
    736
            isWhiteListedForEquityTranche(msg.sender)
    737
        {
    738
            uint256 userShares = s_equityTrancheShares[msg.sender];
    739
            if (userShares == 0) revert TranchePool__InsufficientShares();
    740
    741
            uint256 indexDelta = equityInterestIndex - equityUserIndex[msg.sender];
    742
    743
            if (indexDelta == 0) revert TranchePool__ZeroWithdrawal();
    744
    745
            uint256 claimable = (userShares * indexDelta) / 1e18;
    746
    747
            // CHANGED: update user index BEFORE transfer
    748
            equityUserIndex[msg.sender] = equityInterestIndex;
    749
    750
            IERC20(s_stableCoin).safeTransfer(msg.sender, claimable);
    751
        }
    752
    753
        /**
    754
         *
    755
         *
    756
         * @notice Withdraw from senior tranche by burning shares
    757
         * @param shares Number of shares to burn (0 = withdraw all)
    758
         * passing zero amount will cause the burn of all shares
    759
         */
    760
        function withdrawSeniorTranche(
    761
            uint256 shares
    762
        ) external isWhiteListed(msg.sender) {
    763
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    764
                revert TranchePool__WithdrawNotAllowed(poolState);
    765
            }
    766
            uint256 userShares = s_seniorTrancheShares[msg.sender];
    767
    768
            if (userShares == 0) {
    769
                revert TranchePool__InsufficientShares();
    770
            }
    771
    772
            // If shares is 0, withdraw everything
    773
            uint256 sharesToBurn = shares == 0 ? userShares : shares;
    774
    775
            if (sharesToBurn > userShares) {
    776
                revert TranchePool__InsufficientShares();
    777
            }
    778
    779
            // Calculate amount to withdraw based on current pool value
    780
            uint256 amountToWithdraw = (sharesToBurn * s_seniorTrancheIdleValue) /
    781
                s_totalSeniorShares;
    782
    783
            if (amountToWithdraw == 0) {
    784
                revert TranchePool__ZeroWithdrawal();
    785
            }
    786
    787
            if (amountToWithdraw > s_seniorTrancheIdleValue) {
    788
                revert TranchePool__InsufficientLiquidity();
    789
            }
    790
    791
            // Update state before transfer (CEI pattern)
    792
            s_seniorTrancheShares[msg.sender] -= sharesToBurn;
    793
            s_totalSeniorShares -= sharesToBurn;
    794
            s_seniorTrancheIdleValue -= amountToWithdraw;
    795
            s_totalDeposited -= amountToWithdraw;
    796
            // Transfer tokens
    797
            IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);
    798
    799
            emit WithdrawnFromSeniorTranche(
    800
                msg.sender,
    801
                amountToWithdraw,
    802
                sharesToBurn,
    803
                block.timestamp
    804
            );
    805
        }
    806
    807
        /**
    808
         * @notice Withdraw from junior tranche by burning shares
    809
         * @param shares Number of shares to burn (0 = withdraw all)
    810
         */
    811
        function withdrawJuniorTranche(
    812
            uint256 shares
    813
        ) external isWhiteListed(msg.sender) {
    814
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    815
                revert TranchePool__WithdrawNotAllowed(poolState);
    816
            }
    817
            uint256 userShares = s_juniorTrancheShares[msg.sender];
    818
    819
            if (userShares == 0) {
    820
                revert TranchePool__InsufficientShares();
    821
            }
    822
    823
            uint256 sharesToBurn = shares == 0 ? userShares : shares;
    824
    825
            if (sharesToBurn > userShares) {
    826
                revert TranchePool__InsufficientShares();
    827
            }
    828
    829
            uint256 amountToWithdraw = (sharesToBurn * s_juniorTrancheIdleValue) /
    830
                s_totalJuniorShares;
    831
    832
            if (amountToWithdraw == 0) {
    833
                revert TranchePool__ZeroWithdrawal();
    834
            }
    835
            if (amountToWithdraw > s_juniorTrancheIdleValue) {
    836
                revert TranchePool__InsufficientLiquidity();
    837
            }
    838
    839
            s_juniorTrancheShares[msg.sender] -= sharesToBurn;
    840
            s_totalJuniorShares -= sharesToBurn;
    841
            s_juniorTrancheIdleValue -= amountToWithdraw;
    842
            s_totalDeposited -= amountToWithdraw;
    843
    844
            IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);
    845
    846
            emit WithdrawnFromJuniorTranche(
    847
                msg.sender,
    848
                amountToWithdraw,
    849
                sharesToBurn,
    850
                block.timestamp
    851
            );
    852
        }
    853
    854
        function withdrawEquityTranche(
    855
            uint256 shares
    856
        ) external isWhiteListedForEquityTranche(msg.sender) {
    857
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    858
                revert TranchePool__WithdrawNotAllowed(poolState);
    859
            }
    860
            uint256 userShares = s_equityTrancheShares[msg.sender];
    861
    862
            if (userShares == 0) {
    863
                revert TranchePool__InsufficientShares();
    864
            }
    865
    866
            uint256 sharesToBurn = shares == 0 ? userShares : shares;
    867
            if (sharesToBurn > userShares) {
    868
                revert TranchePool__InsufficientShares();
    869
            }
    870
    871
            uint256 amountToWithdraw = (sharesToBurn * s_equityTrancheIdleValue) /
    872
                s_totalEquityShares;
    873
    874
            if (amountToWithdraw == 0) {
    875
                revert TranchePool__ZeroWithdrawal();
    876
            }
    877
            if (amountToWithdraw > s_equityTrancheIdleValue) {
    878
                revert TranchePool__InsufficientLiquidity();
    879
            }
    880
            s_equityTrancheShares[msg.sender] -= sharesToBurn;
    881
            s_totalEquityShares -= sharesToBurn;
    882
            s_equityTrancheIdleValue -= amountToWithdraw;
    883
            s_totalDeposited -= amountToWithdraw;
    884
    885
            IERC20(s_stableCoin).safeTransfer(msg.sender, amountToWithdraw);
    886
    887
            emit WithdrawnFromEquityTranche(
    888
                msg.sender,
    889
                amountToWithdraw,
    890
                sharesToBurn,
    891
                block.timestamp
    892
            );
    893
        }
    894
    895
        /**
    896
         * @notice Withdraw specific amount from senior tranche
    897
         * @param amount Amount of tokens to withdraw
    898
         */
    899
        function withdrawSeniorTrancheByAmount(
    900
            uint256 amount
    901
        ) external isWhiteListed(msg.sender) {
    902
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    903
                revert TranchePool__WithdrawNotAllowed(poolState);
    904
            }
    905
            if (amount == 0) {
    906
                revert TranchePool__ZeroWithdrawal();
    907
            }
    908
    909
            uint256 userBalance = getSeniorTrancheBalance(msg.sender);
    910
    911
            if (amount > userBalance) {
    912
                revert TranchePool__InsufficientShares();
    913
            }
    914
    915
            if (amount > s_seniorTrancheIdleValue) {
    916
                revert TranchePool__InsufficientLiquidity();
    917
            }
    918
    919
            // Calculate shares to burn for this amount
    920
            uint256 sharesToBurn = (amount * s_totalSeniorShares) /
    921
                (s_seniorTrancheIdleValue);
    922
    923
            // Handle rounding - ensure we don't try to withdraw more than available
    924
            if (sharesToBurn > s_seniorTrancheShares[msg.sender]) {
    925
                sharesToBurn = s_seniorTrancheShares[msg.sender];
    926
            }
    927
    928
            s_seniorTrancheShares[msg.sender] -= sharesToBurn;
    929
            s_totalSeniorShares -= sharesToBurn;
    930
            s_seniorTrancheIdleValue -= amount;
    931
            s_totalDeposited -= amount;
    932
    933
            IERC20(s_stableCoin).safeTransfer(msg.sender, amount);
    934
    935
            emit WithdrawnFromSeniorTranche(
    936
                msg.sender,
    937
                amount,
    938
                sharesToBurn,
    939
                block.timestamp
    940
            );
    941
        }
    942
    943
        /**
    944
         * @notice Withdraw specific amount from junior tranche
    945
         * @param amount Amount of tokens to withdraw
    946
         */
    947
        function withdrawJuniorTrancheByAmount(
    948
            uint256 amount
    949
        ) external isWhiteListed(msg.sender) {
    950
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    951
                revert TranchePool__WithdrawNotAllowed(poolState);
    952
            }
    953
            if (amount == 0) {
    954
                revert TranchePool__ZeroWithdrawal();
    955
            }
    956
    957
            uint256 userBalance = getJuniorTrancheBalance(msg.sender);
    958
    959
            if (amount > userBalance) {
    960
                revert TranchePool__InsufficientShares();
    961
            }
    962
    963
            if (amount > s_juniorTrancheIdleValue) {
    964
                revert TranchePool__InsufficientLiquidity();
    965
            }
    966
    967
            uint256 sharesToBurn = (amount * s_totalJuniorShares) /
    968
                (s_juniorTrancheIdleValue);
    969
    970
            if (sharesToBurn > s_juniorTrancheShares[msg.sender]) {
    971
                sharesToBurn = s_juniorTrancheShares[msg.sender];
    972
            }
    973
    974
            s_juniorTrancheShares[msg.sender] -= sharesToBurn;
    975
            s_totalJuniorShares -= sharesToBurn;
    976
            s_juniorTrancheIdleValue -= amount;
    977
            s_totalDeposited -= amount;
    978
    979
            IERC20(s_stableCoin).safeTransfer(msg.sender, amount);
    980
    981
            emit WithdrawnFromJuniorTranche(
    982
                msg.sender,
    983
                amount,
    984
                sharesToBurn,
    985
                block.timestamp
    986
            );
    987
        }
    988
    989
        function withdrawEquityTrancheByAmount(
    990
            uint256 amount
    991
        ) external isWhiteListedForEquityTranche(msg.sender) {
    992
            if (poolState != PoolState.OPEN && poolState != PoolState.CLOSED) {
    993
                revert TranchePool__WithdrawNotAllowed(poolState);
    994
            }
    995
            if (amount == 0) {
    996
                revert TranchePool__ZeroWithdrawal();
    997
            }
    998
    999
            uint256 userBalance = getEquityTrancheBalance(msg.sender);
    1000
    1001
            if (amount > userBalance) {
    1002
                revert TranchePool__InsufficientShares();
    1003
            }
    1004
    1005
            if (amount > s_equityTrancheIdleValue) {
    1006
                revert TranchePool__InsufficientLiquidity();
    1007
            }
    1008
    1009
            uint256 sharesToBurn = (amount * s_totalEquityShares) /
    1010
                (s_equityTrancheIdleValue);
    1011
    1012
            if (sharesToBurn > s_equityTrancheShares[msg.sender]) {
    1013
                sharesToBurn = s_equityTrancheShares[msg.sender];
    1014
            }
    1015
    1016
            s_equityTrancheShares[msg.sender] -= sharesToBurn;
    1017
            s_totalEquityShares -= sharesToBurn;
    1018
            s_equityTrancheIdleValue -= amount;
    1019
            s_totalDeposited -= amount;
    1020
    1021
            IERC20(s_stableCoin).safeTransfer(msg.sender, amount);
    1022
    1023
            emit WithdrawnFromEquityTranche(
    1024
                msg.sender,
    1025
                amount,
    1026
                sharesToBurn,
    1027
                block.timestamp
    1028
            );
    1029
        }
    1030
    1031
        /**
    1032
         * @notice Get the current balance of a user in the senior tranche
    1033
         */
    1034
        function getSeniorTrancheBalance(
    1035
            address user
    1036
        ) public view returns (uint256) {
    1037
            if (s_totalSeniorShares == 0) return 0;
    1038
            return
    1039
                (s_seniorTrancheShares[user] * s_seniorTrancheIdleValue) /
    1040
                s_totalSeniorShares;
    1041
        }
    1042
    1043
        /**
    1044
         * @notice Get the current balance of a user in the junior tranche
    1045
         */
    1046
        function getJuniorTrancheBalance(
    1047
            address user
    1048
        ) public view returns (uint256) {
    1049
            if (s_totalJuniorShares == 0) return 0;
    1050
            return
    1051
                (s_juniorTrancheShares[user] * s_juniorTrancheIdleValue) /
    1052
                s_totalJuniorShares;
    1053
        }
    1054
    1055
        function getEquityTrancheBalance(
    1056
            address user
    1057
        ) public view returns (uint256) {
    1058
            if (s_totalEquityShares == 0) return 0;
    1059
            return
    1060
                (s_equityTrancheShares[user] * s_equityTrancheIdleValue) /
    1061
                s_totalEquityShares;
    1062
        }
    1063
    1064
        // Admin functions
    1065
        function setMinimumDepositAmountJuniorTranche(
    1066
            uint256 amount
    1067
        ) external onlyOwner {
    1068
            if (amount > s_juniorTrancheMaxCap) {
    1069
                revert TranchePool__InvalidMinDepositAmount();
    1070
            }
    1071
            s_minimumDepositAmountJuniorTranche = amount;
    1072
        }
    1073
    1074
        function setMinimumDepositAmountSeniorTranche(
    1075
            uint256 amount
    1076
        ) external onlyOwner {
    1077
            if (amount > s_seniorTrancheMaxCap) {
    1078
                revert TranchePool__InvalidMinDepositAmount();
    1079
            }
    1080
            s_minimumDepositAmountSeniorTranche = amount;
    1081
        }
    1082
    1083
        function setMinimumDepositAmountEquityTranche(
    1084
            uint256 amount
    1085
        ) external onlyOwner {
    1086
            if (amount > s_equityTrancheMaxCap) {
    1087
                revert TranchePool__InvalidMinDepositAmount();
    1088
            }
    1089
            s_minimumDepositAmountEquityTranche = amount;
    1090
        }
    1091
    1092
        function setTrancheCapitalAllocationFactorSenior(
    1093
            uint256 factor
    1094
        ) external onlyOwner {
    1095
            if (factor + s_capital_allocation_factor_junior > 100)
    1096
                revert TranchePool__InvalidAllocationRatio();
    1097
            s_capital_allocation_factor_senior = factor;
    1098
            emit CapitalAllocationFactorUpdatedSenior(factor);
    1099
        }
    1100
    1101
        function setTrancheCapitalAllocationFactorJunior(
    1102
            uint256 factor
    1103
        ) external onlyOwner {
    1104
            if (factor + s_capital_allocation_factor_senior > 100)
    1105
                revert TranchePool__InvalidAllocationRatio();
    1106
            s_capital_allocation_factor_junior = factor;
    1107
            emit CapitalAllocationFactorUpdatedJunior(factor);
    1108
        }
    1109
    1110
        function setSeniorAPR(uint256 apr) external onlyOwner {
    1111
            if (apr == 0) {
    1112
                revert TranchePool__ZeroAPRError();
    1113
            }
    1114
            s_senior_apr = apr;
    1115
        }
    1116
    1117
        function setTargetJuniorAPR(uint256 apr) external onlyOwner {
    1118
            if (apr == 0) {
    1119
                revert TranchePool__ZeroAPRError();
    1120
            }
    1121
            s_target_junior_apr = apr;
    1122
        }
    1123
    1124
        function setPoolState(PoolState newState) external onlyOwner {
    1125
            if (uint256(newState) < uint256(poolState)) {
    1126
                revert TranchePool__InvalidStateTransition(newState);
    1127
            }
    1128
    1129
            if (newState == PoolState.CLOSED) {
    1130
                if (getTotalDeployedValue() > 0) {
    1131
                    revert TranchePool__DeployedCapitalExists();
    1132
                }
    1133
            }
    1134
    1135
            poolState = newState;
    1136
    1137
            emit PoolStateUpdated(newState);
    1138
        }
    1139
    1140
        function setLoanEngine(address _loanEngine) external onlyOwner {
    1141
            if (_loanEngine == address(0)) {
    1142
                revert TranchePool__ZeroAddressError();
    1143
            }
    1144
            loanEngine = _loanEngine;
    1145
        }
    1146
    1147
        function setMaxAllocationCapSeniorTranche(
    1148
            uint256 amount
    1149
        ) external onlyOwner {
    1150
            if (amount == 0) {
    1151
                revert TranchePool__ZeroValueError();
    1152
            }
    1153
            if (amount < s_minimumDepositAmountSeniorTranche) {
    1154
                revert TranchePool__InvalidMaxCapAmount();
    1155
            }
    1156
            s_seniorTrancheMaxCap = amount;
    1157
        }
    1158
    1159
        function setMaxAllocationCapJuniorTranche(
    1160
            uint256 amount
    1161
        ) external onlyOwner {
    1162
            if (amount == 0) {
    1163
                revert TranchePool__ZeroValueError();
    1164
            }
    1165
            if (amount < s_minimumDepositAmountJuniorTranche) {
    1166
                revert TranchePool__InvalidMaxCapAmount();
    1167
            }
    1168
            s_juniorTrancheMaxCap = amount;
    1169
        }
    1170
    1171
        function setMaxAllocationCapEquityTranche(
    1172
            uint256 amount
    1173
        ) external onlyOwner {
    1174
            if (amount == 0) {
    1175
                revert TranchePool__ZeroValueError();
    1176
            }
    1177
            if (amount < s_minimumDepositAmountEquityTranche) {
    1178
                revert TranchePool__InvalidMaxCapAmount();
    1179
            }
    1180
            s_equityTrancheMaxCap = amount;
    1181
        }
    1182
    1183
        function updateWhitelist(address user, bool status) external onlyOwner {
    1184
            whiteListedLps[user] = status;
    1185
        }
    1186
    1187
        function updateEquityTrancheWhiteList(
    1188
            address user,
    1189
            bool status
    1190
        ) external onlyOwner {
    1191
            whiteListedForEquityTranche[user] = status;
    1192
        }
    1193
    1194
        function _minimum(uint256 a, uint256 b) internal pure returns (uint256) {
    1195
            if (a > b) {
    1196
                return b;
    1197
            } else {
    1198
                return a;
    1199
            }
    1200
        }
    1201
    1202
        // getters
    1203
    1204
        function getSeniorTrancheMaxDepositCap() external view returns (uint256) {
    1205
            return s_seniorTrancheMaxCap;
    1206
        }
    1207
    1208
        function getSeniorTrancheMinimumDepositAmount()
    1209
            external
    1210
            view
    1211
            returns (uint256)
    1212
        {
    1213
            return s_minimumDepositAmountSeniorTranche;
    1214
        }
    1215
    1216
        function getSeniorTrancheShares(
    1217
            address user
    1218
        ) external view returns (uint256) {
    1219
            return s_seniorTrancheShares[user];
    1220
        }
    1221
    1222
        function getTotalSeniorShares() external view returns (uint256) {
    1223
            return s_totalSeniorShares;
    1224
        }
    1225
    1226
        function getSeniorTrancheIdleValue() external view returns (uint256) {
    1227
            return s_seniorTrancheIdleValue;
    1228
        }
    1229
    1230
        function getSeniorTrancheDeployedValue() external view returns (uint256) {
    1231
            return s_seniorTrancheDeployedValue;
    1232
        }
    1233
    1234
        function getSeniorInterestIndex() external view returns (uint256) {
    1235
            return seniorInterestIndex;
    1236
        }
    1237
    1238
        function getSeniorUserIndex(address user) external view returns (uint256) {
    1239
            return seniorUserIndex[user];
    1240
        }
    1241
    1242
        function getJuniorTrancheMaxDepositCap() external view returns (uint256) {
    1243
            return s_juniorTrancheMaxCap;
    1244
        }
    1245
    1246
        function getJuniorInterestIndex() external view returns (uint256) {
    1247
            return juniorInterestIndex;
    1248
        }
    1249
    1250
        function getJuniorTrancheMinimumDepositAmount()
    1251
            external
    1252
            view
    1253
            returns (uint256)
    1254
        {
    1255
            return s_minimumDepositAmountJuniorTranche;
    1256
        }
    1257
    1258
        function getJuniorTrancheShares(
    1259
            address user
    1260
        ) external view returns (uint256) {
    1261
            return s_juniorTrancheShares[user];
    1262
        }
    1263
    1264
        function getTotalJuniorShares() external view returns (uint256) {
    1265
            return s_totalJuniorShares;
    1266
        }
    1267
    1268
        function getJuniorTrancheIdleValue() external view returns (uint256) {
    1269
            return s_juniorTrancheIdleValue;
    1270
        }
    1271
    1272
        function getJuniorTrancheDeployedValue() external view returns (uint256) {
    1273
            return s_juniorTrancheDeployedValue;
    1274
        }
    1275
    1276
        function getJuniorUserIndex(address user) external view returns (uint256) {
    1277
            return juniorUserIndex[user];
    1278
        }
    1279
    1280
        function getEquityTrancheMaxDepositCap() external view returns (uint256) {
    1281
            return s_equityTrancheMaxCap;
    1282
        }
    1283
    1284
        function getEquityTrancheShares(
    1285
            address user
    1286
        ) external view returns (uint256) {
    1287
            return s_equityTrancheShares[user];
    1288
        }
    1289
    1290
        function getTotalEquityShares() external view returns (uint256) {
    1291
            return s_totalEquityShares;
    1292
        }
    1293
    1294
        function getEquityTrancheMinimumDepositAmount()
    1295
            external
    1296
            view
    1297
            returns (uint256)
    1298
        {
    1299
            return s_minimumDepositAmountEquityTranche;
    1300
        }
    1301
    1302
        function getEquityTrancheIdleValue() external view returns (uint256) {
    1303
            return s_equityTrancheIdleValue;
    1304
        }
    1305
    1306
        function getEquityTrancheDeployedValue() external view returns (uint256) {
    1307
            return s_equityTrancheDeployedValue;
    1308
        }
    1309
    1310
        function getEquityUserIndex(address user) external view returns (uint256) {
    1311
            return equityUserIndex[user];
    1312
        }
    1313
    1314
        function getPoolState() external view returns (PoolState) {
    1315
            return poolState;
    1316
        }
    1317
    1318
        function getTotalDeployedValue() public view returns (uint256) {
    1319
            return
    1320
                s_seniorTrancheDeployedValue +
    1321
                s_juniorTrancheDeployedValue +
    1322
                s_equityTrancheDeployedValue;
    1323
        }
    1324
    1325
        function getTotalIdleValue() external view returns (uint256) {
    1326
            return
    1327
                s_seniorTrancheIdleValue +
    1328
                s_juniorTrancheIdleValue +
    1329
                s_equityTrancheIdleValue;
    1330
        }
    1331
    1332
        function getSeniorAllocationRatio() external view returns (uint256) {
    1333
            return s_capital_allocation_factor_senior;
    1334
        }
    1335
    1336
        function getJuniorAllocationRatio() external view returns (uint256) {
    1337
            return s_capital_allocation_factor_junior;
    1338
        }
    1339
    1340
        function getTotalDeposited() external view returns (uint256) {
    1341
            return s_totalDeposited;
    1342
        }
    1343
    1344
        function getTotalLoss() external view returns (uint256) {
    1345
            return s_totalLoss;
    1346
        }
    1347
    1348
        function getTotalRecovered() external view returns (uint256) {
    1349
            return s_totalRecovered;
    1350
        }
    1351
    1352
        function getProtocolRevenue() external view returns (uint256) {
    1353
            return s_protocolRevenue;
    1354
        }
    1355
    }
    1356
    0.0% src/interfaces/ICreditPolicy.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    import {CreditPolicy} from "../CreditPolicy.sol";
    4
    5
    interface ICreditPolicy {
    6
        function createPolicy(uint256 version) external;
    7
    8
        function freezePolicy(uint256 version) external;
    9
    10
        function deActivatePolicy(uint256 version) external;
    11
    12
        function updateEligibility(
    13
            uint256 version,
    14
            CreditPolicy.EligibilityCriteria calldata data
    15
        ) external;
    16
    17
        function updateRatios(
    18
            uint256 version,
    19
            CreditPolicy.FinancialRatios calldata data
    20
        ) external;
    21
    22
        function updateConcentration(
    23
            uint256 version,
    24
            CreditPolicy.ConcentrationLimits calldata data
    25
        ) external;
    26
    27
        function updateAttestation(
    28
            uint256 version,
    29
            CreditPolicy.AttestationRequirements calldata data
    30
        ) external;
    31
    32
        function updateCovenants(
    33
            uint256 version,
    34
            CreditPolicy.MaintenanceCovenants calldata data
    35
        ) external;
    36
    37
        function setLoanTier(
    38
            uint256 version,
    39
            uint8 tierId,
    40
            CreditPolicy.LoanTier calldata tier
    41
        ) external;
    42
    43
        function excludeIndustry(uint256 version, bytes32 industry) external;
    44
    45
        function includeIndustry(uint256 version, bytes32 industry) external;
    46
    47
        function setPolicyDocument(
    48
            uint256 version,
    49
            bytes32 hash,
    50
            string calldata uri
    51
        ) external;
    52
    53
        function tierExistsInPolicy(
    54
            uint256 version,
    55
            uint8 tierId
    56
        ) external view returns (bool);
    57
    58
        function changePolicyAdmin(address newAdmin) external;
    59
    60
        function isPolicyActive(uint256 version) external view returns (bool);
    61
    62
        function isPolicyFrozen(uint256 version) external view returns (bool);
    63
    64
        function isIndustryExcluded(
    65
            uint256 version,
    66
            bytes32 industry
    67
        ) external view returns (bool);
    68
    }
    69
    0.0% src/interfaces/ITranchePool.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    import {TranchePool} from "../TranchePool.sol";
    4
    5
    interface ITranchePool {
    6
        // logic functions
    7
    8
        function withdrawEquityTrancheByAmount(uint256 amount) external;
    9
    10
        function withdrawJuniorTrancheByAmount(uint256 amount) external;
    11
    12
        function withdrawSeniorTrancheByAmount(uint256 amount) external;
    13
    14
        function withdrawEquityTranche(uint256 shares) external;
    15
    16
        function withdrawJuniorTranche(uint256 shares) external;
    17
    18
        function withdrawSeniorTranche(uint256 shares) external;
    19
    20
        function onInterestAccrued(
    21
            uint256 interestAmount,
    22
            uint256 seniorInterest,
    23
            uint256 juniorInterest
    24
        ) external;
    25
    26
        function onRepayment(
    27
            uint256 principalRepaid,
    28
            uint256 interestRepaid
    29
        ) external;
    30
    31
        function onRecovery(uint256 amount) external;
    32
    33
        function allocateCapital(
    34
            uint256 totalDisbursement,
    35
            uint256 fees,
    36
            address deployer,
    37
            address feeManager
    38
        )
    39
            external
    40
            returns (
    41
                uint256 seniorAmount,
    42
                uint256 juniorAmount,
    43
                uint256 equityAmount
    44
            );
    45
    46
        function depositEquityTranche(uint256 amount) external;
    47
    48
        function depositJuniorTranche(uint256 amount) external;
    49
    50
        function depositSeniorTranche(uint256 amount) external;
    51
    52
        // updaters
    53
        function updateEquityTrancheWhiteList(address user, bool status) external;
    54
    55
        function updateWhitelist(address user, bool status) external;
    56
    57
        // setters
    58
    59
        function onLoss(uint256 principalLoss, uint256 interestAccrued) external;
    60
    61
        function setLoanEngine(address _loanEngine) external;
    62
    63
        function setTargetJuniorAPR(uint256 apr) external;
    64
    65
        function setSeniorAPR(uint256 apr) external;
    66
    67
        function setTrancheCapitalAllocationFactorJunior(uint256 factor) external;
    68
    69
        function setTrancheCapitalAllocationFactorSenior(uint256 factor) external;
    70
    71
        function setMinimumDepositAmountEquityTranche(uint256 amount) external;
    72
    73
        function setMinimumDepositAmountSeniorTranche(uint256 amount) external;
    74
    75
        function setMinimumDepositAmountJuniorTranche(uint256 amount) external;
    76
    77
        // getters
    78
        function getEquityTrancheBalance(
    79
            address user
    80
        ) external view returns (uint256);
    81
    82
        function getJuniorTrancheBalance(
    83
            address user
    84
        ) external view returns (uint256);
    85
    86
        function getSeniorTrancheBalance(
    87
            address user
    88
        ) external view returns (uint256);
    89
    90
        function getPoolState() external view returns (TranchePool.PoolState);
    91
    92
        function getSeniorAllocationRatio() external view returns (uint256);
    93
    94
        function getJuniorAllocationRatio() external view returns (uint256);
    95
    96
        function getTotalIdleValue() external view returns (uint256);
    97
    }
    98
    0.0% src/interfaces/IVerifier.sol
    Lines covered: 0 / 0 (0.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    4
    interface IVerifier {
    5
        function verify(
    6
            bytes calldata _proof,
    7
            bytes32[] calldata _publicInputs
    8
        ) external returns (bool);
    9
    }
    10
    100.0% test/fuzz/invariant/CreditRailStateFullFuzzTest.t.sol
    Lines covered: 71 / 71 (100.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.27;
    3
    4
    import {LoanEngine} from "../../../src/LoanEngine.sol";
    5
    import {TranchePool} from "../../../src/TranchePool.sol";
    6
    import {CreditPolicy} from "../../../src/CreditPolicy.sol";
    7
    import {MockLoanProofVerifier} from "../../mocks/MockLoanProofVerifier.sol";
    8
    import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
    9
    10
    import {Handler} from "./Handler.t.sol";
    11
    import {Test} from "forge-std/Test.sol";
    12
    import {StdInvariant} from "forge-std/StdInvariant.sol";
    13
    14
    // we assume protocol revenue is zero as we have equity tranche
    15
    contract CreditRailStateFullFuzzTest is StdInvariant, Test {
    16
        Handler public handler;
    17
        ERC20Mock public usdt;
    18
        uint256 public maxOriginationFeeBps = 500; // 5%
    19
        TranchePool public tranchePool;
    20
        LoanEngine public loanEngine;
    21
        CreditPolicy public creditPolicy;
    22
        uint256 public USDT = 1e18;
    23
        address public deployer = makeAddr("deployer");
    24
    25
        constructor() {
    26
            vm.startPrank(deployer);
    27
            usdt = new ERC20Mock();
    28
            tranchePool = new TranchePool(address(usdt));
    29
            tranchePool.setMaxAllocationCapSeniorTranche(5_00_00_000 * USDT);
    30
            tranchePool.setMaxAllocationCapJuniorTranche(3_00_00_000 * USDT);
    31
            tranchePool.setMaxAllocationCapEquityTranche(2_00_00_000 * USDT);
    32
            tranchePool.setMinimumDepositAmountSeniorTranche(10_00_000 * USDT);
    33
            tranchePool.setMinimumDepositAmountJuniorTranche(50_00_000 * USDT);
    34
            tranchePool.setMinimumDepositAmountEquityTranche(1_00_00_000 * USDT);
    35
            tranchePool.setTrancheCapitalAllocationFactorJunior(15);
    36
            tranchePool.setTrancheCapitalAllocationFactorSenior(80);
    37
            tranchePool.setSeniorAPR(8);
    38
            tranchePool.setTargetJuniorAPR(15);
    39
    40
            creditPolicy = new CreditPolicy();
    41
            creditPolicy.setMaxTiers(3);
    42
            creditPolicy.createPolicy(1);
    43
    44
            creditPolicy.updateEligibility(1, _createEligibilityCriteria());
    45
            creditPolicy.updateRatios(1, _createFinancialRatios());
    46
            creditPolicy.updateConcentration(1, _createConcentrationLimits());
    47
            creditPolicy.updateAttestation(1, _createAttestationRequirements());
    48
            creditPolicy.updateCovenants(1, _createMaintenanceCovenants());
    49
            creditPolicy.setLoanTier(1, 1, _createMockTier("Tier 1"));
    50
            creditPolicy.setPolicyDocument(
    51
                1,
    52
                _hashString("document"),
    53
                "ipfs://policyDocHash"
    54
            );
    55
            creditPolicy.freezePolicy(1);
    56
    57
            MockLoanProofVerifier mockLoanProofVerifier = new MockLoanProofVerifier();
    58
            loanEngine = new LoanEngine(
    59
                address(creditPolicy),
    60
                address(mockLoanProofVerifier),
    61
                maxOriginationFeeBps,
    62
                address(tranchePool),
    63
                address(usdt)
    64
            );
    65
            loanEngine.setMaxOriginationFeeBps(500);
    66
            tranchePool.setLoanEngine(address(loanEngine));
    67
    68
            handler = new Handler(loanEngine, tranchePool, creditPolicy, usdt);
    69
            vm.stopPrank();
    70
            bytes4[] memory selectors = new bytes4[](11);
    71
            selectors[0] = handler.depositSeniorTranche.selector;
    72
            selectors[1] = handler.depositJuniorTranche.selector;
    73
            selectors[2] = handler.depositEquityTranche.selector;
    74
            selectors[3] = handler.maybeCommitPool.selector;
    75
            selectors[4] = handler.createLoan.selector;
    76
            selectors[5] = handler.activateLoan.selector;
    77
            selectors[6] = handler.repayLoan.selector;
    78
            selectors[7] = handler.maybeDeclareDefault.selector;
    79
            selectors[8] = handler.maybeWriteOffLoan.selector;
    80
            selectors[9] = handler.maybeRecoverLoan.selector;
    81
            selectors[10] = handler.warpTime.selector;
    82
            targetSelector(
    83
                FuzzSelector({addr: address(handler), selectors: selectors})
    84
            );
    85
            targetContract(address(handler));
    86
        }
    87
    88
        function _createEligibilityCriteria()
    89
            internal
    90
            pure
    91
            returns (CreditPolicy.EligibilityCriteria memory)
    92
        {
    93
            return
    94
                CreditPolicy.EligibilityCriteria({
    95
                    minAnnualRevenue: 1_00_00_000,
    96
                    minEBITDA: 10_00_000,
    97
                    minTangibleNetWorth: 5_00_00_000,
    98
                    minBusinessAgeDays: 180,
    99
                    maxDefaultsLast36Months: 0,
    100
                    bankruptcyExcluded: true
    101
                });
    102
        }
    103
    104
        function _createFinancialRatios()
    105
            internal
    106
            pure
    107
            returns (CreditPolicy.FinancialRatios memory)
    108
        {
    109
            return
    110
                CreditPolicy.FinancialRatios({
    111
                    maxTotalDebtToEBITDA: 4e18,
    112
                    minInterestCoverageRatio: 2e18,
    113
                    minCurrentRatio: 1e18,
    114
                    minEBITDAMarginBps: 1500
    115
                });
    116
        }
    117
    118
        function _createConcentrationLimits()
    119
            internal
    120
            pure
    121
            returns (CreditPolicy.ConcentrationLimits memory)
    122
        {
    123
            return
    124
                CreditPolicy.ConcentrationLimits({
    125
                    maxSingleBorrowerBps: 1000,
    126
                    maxIndustryConcentrationBps: 3000
    127
                });
    128
        }
    129
    130
        function _createAttestationRequirements()
    131
            internal
    132
            pure
    133
            returns (CreditPolicy.AttestationRequirements memory)
    134
        {
    135
            return
    136
                CreditPolicy.AttestationRequirements({
    137
                    maxAttestationAgeDays: 90,
    138
                    reAttestationFrequencyDays: 180,
    139
                    requiresCPAAttestation: true
    140
                });
    141
        }
    142
    143
        function _createMaintenanceCovenants()
    144
            internal
    145
            pure
    146
            returns (CreditPolicy.MaintenanceCovenants memory)
    147
        {
    148
            return
    149
                CreditPolicy.MaintenanceCovenants({
    150
                    maxLeverageRatio: 4e18,
    151
                    minCoverageRatio: 2e18,
    152
                    minLiquidityAmount: 1_00_00_000,
    153
                    allowsDividends: false,
    154
                    reportingFrequencyDays: 90
    155
                });
    156
        }
    157
    158
        function _createMockTier(
    159
            string memory name
    160
        ) internal pure returns (CreditPolicy.LoanTier memory) {
    161
            return
    162
                CreditPolicy.LoanTier({
    163
                    name: name,
    164
                    minRevenue: 1_00_00_000,
    165
                    maxRevenue: 5_00_00_000,
    166
                    minEBITDA: 10_00_000,
    167
                    maxDebtToEBITDA: 3e18,
    168
                    maxLoanToEBITDA: 2e18,
    169
                    interestRateBps: 800,
    170
                    originationFeeBps: 100,
    171
                    termDays: 365,
    172
                    active: true
    173
                });
    174
        }
    175
    176
        function _hashString(string memory str) internal pure returns (bytes32) {
    177
            return keccak256(bytes(str));
    178
        }
    179
    180
        function invariant__totalIdleAndDeployedValueMatchesAccounting()
    181
            public
    182
            view
    183
        {
    184
            assertEq(
    185
                tranchePool.getTotalIdleValue() +
    186
                    tranchePool.getTotalDeployedValue(),
    187
                tranchePool.getTotalDeposited() -
    188
                    tranchePool.getTotalLoss() +
    189
                    tranchePool.getTotalRecovered(),
    190
                "Total idle and deployed value does not match handler accounting"
    191
            );
    192
        }
    193
    194
        function invariant__OutStandingPrincipalMatchesDeployed() public view {
    195
            assertEq(
    196
                handler.outStandingPrincipal(),
    197
                tranchePool.getTotalDeployedValue(),
    198
                "Outstanding principal does not match deployed minus recovered and loss"
    199
            );
    200
        }
    201
    }
    202
    15.0% test/fuzz/invariant/Handler.t.sol
    Lines covered: 42 / 270 (15.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.27;
    3
    4
    import {Test} from "forge-std/Test.sol";
    5
    import {LoanEngine} from "../../../src/LoanEngine.sol";
    6
    import {TranchePool} from "../../../src/TranchePool.sol";
    7
    import {ERC20Mock} from "@openzeppelin/contracts/mocks/token/ERC20Mock.sol";
    8
    import {CreditPolicy} from "../../../src/CreditPolicy.sol";
    9
    import {MockLoanProofVerifier} from "../../mocks/MockLoanProofVerifier.sol";
    10
    11
    contract Handler is Test {
    12
        LoanEngine loanEngine;
    13
        TranchePool tranchePool;
    14
        ERC20Mock usdt;
    15
        CreditPolicy creditPolicy;
    16
        address deployer = makeAddr("deployer");
    17
        uint256 public USDT = 1e18;
    18
        bool allowFullDeployment = true;
    19
        // 100m$ is the expected principal from lp's
    20
        uint256 public expectedPrincipal = 10_00_00_000 * USDT;
    21
        uint256 public minimumLoanPrincipal = 10_00_000 * USDT;
    22
        uint256 public maximumLoanPrincipal = 2_00_00_000 * USDT;
    23
        uint256 public minimumOriginationFeeBps = 50; // 0.5%
    24
        uint256 public minimumTermDays = 180;
    25
        uint256 public maximumTermDays = 480;
    26
        address[] public seniorUsers;
    27
        address[] public juniorUsers;
    28
        address[] public equityUsers;
    29
        uint256 public activePolicyVersion = 1;
    30
        uint256 public defaultCounter;
    31
        uint256 public writeOffCounter;
    32
        uint256 public recoveryCounter;
    33
    34
        uint256 public seniorTrancheIdleValue;
    35
        uint256 public seniorTrancheDeployedValue;
    36
    37
        uint256 public juniorTrancheIdleValue;
    38
        uint256 public juniorTrancheDeployedValue;
    39
    40
        uint256 public equityTrancheIdleValue;
    41
        uint256 public equityTrancheDeployedValue;
    42
    43
        uint256 public seniorTrancheTotalShares;
    44
        mapping(address => uint256) public seniorTrancheShares;
    45
        mapping(address => uint256) public seniorTrancheDeposits;
    46
        mapping(address => uint256) public seniorUserIndex;
    47
    48
        uint256 public juniorTrancheTotalShares;
    49
        mapping(address => uint256) public juniorTrancheShares;
    50
        mapping(address => uint256) public juniorTrancheDeposits;
    51
        mapping(address => uint256) public juniorUserIndex;
    52
    53
        address[] public loanBorrowers;
    54
    55
        address public recevingEntity = makeAddr("recevingEntity");
    56
        address public feeManager = makeAddr("feeManager");
    57
    58
        uint256 public totalIdleValue;
    59
        uint256 public totalDeployedValue;
    60
        uint256 public totalDeposited;
    61
        uint256 public totalLoss;
    62
        uint256 public totalRecovered;
    63
    64
        uint256 public outStandingPrincipal;
    65
    66
        constructor(
    67
            LoanEngine _loanEngine,
    68
            TranchePool _tranchePool,
    69
            CreditPolicy _creditPolicy,
    70
            ERC20Mock _usdt
    71
        ) {
    72
            loanEngine = _loanEngine;
    73
            tranchePool = _tranchePool;
    74
            usdt = _usdt;
    75
            creditPolicy = _creditPolicy;
    76
    77
            vm.startPrank(deployer);
    78
            loanEngine.setWhitelistedFeeManager(feeManager, true);
    79
            loanEngine.setWhitelistedOffRampingEntity(recevingEntity, true);
    80
            loanEngine.setWhitelistedRepaymentAgent(recevingEntity, true);
    81
            loanEngine.setWhitelistedRecoveryAgent(recevingEntity, true);
    82
    83
            for (uint160 i = 1; i < 100; i++) {
    84
                seniorUsers.push(address(i));
    85
                if (i % 2 == 0) {
    86
                    ERC20Mock(usdt).mint(address(i), 1_00_00_00000 * 1e18);
    87
                    tranchePool.updateWhitelist(address(i), true);
    88
                } else if (i % 3 == 0) {
    89
                    ERC20Mock(usdt).mint(address(i), 50_0000_0000 * 1e18);
    90
                    tranchePool.updateWhitelist(address(i), true);
    91
                } else {
    92
                    ERC20Mock(usdt).mint(address(i), 10_000_0000000 * 1e18);
    93
                    tranchePool.updateWhitelist(address(i), true);
    94
                }
    95
            }
    96
            for (uint160 i = 1; i < 10; i++) {
    97
                juniorUsers.push(address(i));
    98
                if (i % 2 == 0) {
    99
                    ERC20Mock(usdt).mint(address(i), 500000_00_000 * 1e18);
    100
                    tranchePool.updateWhitelist(address(i), true);
    101
                } else {
    102
                    tranchePool.updateWhitelist(address(i), true);
    103
                    ERC20Mock(usdt).mint(address(i), 10_000000_000 * 1e18);
    104
                }
    105
            }
    106
            for (uint160 i = 1; i < 5; i++) {
    107
                equityUsers.push(address(i));
    108
                ERC20Mock(usdt).mint(address(i), 50_0000_0000 * 1e18);
    109
                tranchePool.updateEquityTrancheWhiteList(address(i), true);
    110
            }
    111
    112
            for (uint160 i = 200; i < 220; i++) {
    113
                loanBorrowers.push(address(i));
    114
            }
    115
            ERC20Mock(usdt).mint(address(recevingEntity), 50_0000_0000 * 1e18);
    116
    117
            vm.stopPrank();
    118
        }
    119
    120
        function depositSeniorTranche(uint256 userIndex, uint256 amount) public {
    121
            if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) {
    122
                return;
    123
            }
    124
            address user = seniorUsers[userIndex % seniorUsers.length];
    125
            amount = bound(
    126
                amount,
    127
                tranchePool.getSeniorTrancheMinimumDepositAmount(),
    128
                tranchePool.getSeniorTrancheMaxDepositCap()
    129
            );
    130
            if (
    131
                amount + seniorTrancheIdleValue + seniorTrancheDeployedValue >
    132
                tranchePool.getSeniorTrancheMaxDepositCap()
    133
            ) {
    134
                amount =
    135
                    tranchePool.getSeniorTrancheMaxDepositCap() -
    136
                    seniorTrancheIdleValue -
    137
                    seniorTrancheDeployedValue;
    138
                if (amount < tranchePool.getSeniorTrancheMinimumDepositAmount()) {
    139
                    return;
    140
                }
    141
            }
    142
            if (amount == 0) return;
    143
            vm.startPrank(user);
    144
            ERC20Mock(usdt).approve(address(tranchePool), amount);
    145
            tranchePool.depositSeniorTranche(amount);
    146
            seniorTrancheIdleValue += amount;
    147
            seniorTrancheDeposits[user] += amount;
    148
            seniorTrancheShares[user] += amount;
    149
            seniorTrancheTotalShares += amount;
    150
            totalIdleValue += amount;
    151
            seniorUserIndex[user] = tranchePool.getSeniorInterestIndex();
    152
            vm.stopPrank();
    153
        }
    154
    155
        function depositJuniorTranche(uint256 userIndex, uint256 amount) public {
    156
            if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) {
    157
                return;
    158
            }
    159
            address user = juniorUsers[userIndex % juniorUsers.length];
    160
            amount = bound(
    161
                amount,
    162
                tranchePool.getJuniorTrancheMinimumDepositAmount(),
    163
                tranchePool.getJuniorTrancheMaxDepositCap()
    164
            );
    165
            if (
    166
                amount + juniorTrancheIdleValue + juniorTrancheDeployedValue >
    167
                tranchePool.getJuniorTrancheMaxDepositCap()
    168
            ) {
    169
                amount =
    170
                    tranchePool.getJuniorTrancheMaxDepositCap() -
    171
                    juniorTrancheIdleValue -
    172
                    juniorTrancheDeployedValue;
    173
                if (amount < tranchePool.getJuniorTrancheMinimumDepositAmount()) {
    174
                    return;
    175
                }
    176
            }
    177
            if (amount == 0) return;
    178
            vm.startPrank(user);
    179
            ERC20Mock(usdt).approve(address(tranchePool), amount);
    180
            tranchePool.depositJuniorTranche(amount);
    181
            juniorTrancheIdleValue += amount;
    182
            juniorTrancheDeposits[user] += amount;
    183
            juniorTrancheShares[user] += amount;
    184
            juniorTrancheTotalShares += amount;
    185
            totalIdleValue += amount;
    186
            juniorUserIndex[user] = tranchePool.getJuniorInterestIndex();
    187
            vm.stopPrank();
    188
        }
    189
    190
        function depositEquityTranche(uint256 userIndex, uint256 amount) public {
    191
            if (tranchePool.getPoolState() != TranchePool.PoolState.OPEN) {
    192
                return;
    193
            }
    194
            address user = equityUsers[userIndex % equityUsers.length];
    195
            amount = bound(
    196
                amount,
    197
                tranchePool.getEquityTrancheMinimumDepositAmount(),
    198
                tranchePool.getEquityTrancheMaxDepositCap()
    199
            );
    200
            if (
    201
                amount +
    202
                    tranchePool.getEquityTrancheIdleValue() +
    203
                    tranchePool.getEquityTrancheDeployedValue() >
    204
                tranchePool.getEquityTrancheMaxDepositCap()
    205
            ) {
    206
                amount =
    207
                    tranchePool.getEquityTrancheMaxDepositCap() -
    208
                    tranchePool.getEquityTrancheIdleValue() -
    209
                    tranchePool.getEquityTrancheDeployedValue();
    210
                if (amount < tranchePool.getEquityTrancheMinimumDepositAmount()) {
    211
                    return;
    212
                }
    213
            }
    214
            if (amount == 0) return;
    215
            vm.startPrank(user);
    216
            ERC20Mock(usdt).approve(address(tranchePool), amount);
    217
            tranchePool.depositEquityTranche(amount);
    218
            equityTrancheIdleValue += amount;
    219
            totalIdleValue += amount;
    220
            vm.stopPrank();
    221
        }
    222
    223
        function maybeCommitPool() public {
    224
            if (
    225
                tranchePool.getPoolState() == TranchePool.PoolState.OPEN &&
    226
                tranchePool.getTotalIdleValue() > 0
    227
            ) {
    228
                vm.prank(deployer);
    229
                tranchePool.setPoolState(TranchePool.PoolState.COMMITED);
    230
                totalDeposited = tranchePool.getTotalIdleValue();
    231
            }
    232
        }
    233
    234
        function createLoan(
    235
            uint256 principalIssued,
    236
            uint256 originationFeeBps,
    237
            uint256 termDays,
    238
            uint256 userIndex
    239
        ) public {
    240
            if (
    241
                tranchePool.getPoolState() != TranchePool.PoolState.COMMITED &&
    242
                tranchePool.getPoolState() != TranchePool.PoolState.DEPLOYED
    243
            ) {
    244
                return;
    245
            }
    246
            // 10% is reserved(no full deployment)
    247
            uint256 minPrincipal = minimumLoanPrincipal;
    248
    249
            if (allowFullDeployment) {
    250
                if (tranchePool.getTotalIdleValue() < minPrincipal) {
    251
                    minPrincipal = tranchePool.getTotalIdleValue();
    252
                }
    253
            } else {
    254
                if (tranchePool.getTotalIdleValue() < minPrincipal * 10) {
    255
                    return;
    256
                }
    257
            }
    258
    259
            if (tranchePool.getTotalIdleValue() < minimumLoanPrincipal) {
    260
                return;
    261
            }
    262
    263
            principalIssued = bound(
    264
                principalIssued,
    265
                minimumLoanPrincipal,
    266
                _min(maximumLoanPrincipal, tranchePool.getTotalIdleValue())
    267
            );
    268
    269
            if (principalIssued > tranchePool.getTotalIdleValue() / 10) {
    270
                principalIssued = tranchePool.getTotalIdleValue() / 10;
    271
            }
    272
    273
            originationFeeBps = bound(
    274
                originationFeeBps,
    275
                minimumOriginationFeeBps,
    276
                loanEngine.getMaxOriginationFeeBps()
    277
            );
    278
            termDays = bound(termDays, minimumTermDays, maximumTermDays);
    279
            if (!creditPolicy.isPolicyFrozen(activePolicyVersion)) {
    280
                return;
    281
            }
    282
    283
            bytes32 borrowerCommitment = keccak256(
    284
                abi.encodePacked(
    285
                    loanBorrowers[userIndex % loanBorrowers.length],
    286
                    userIndex
    287
                )
    288
            );
    289
    290
            // Get nextLoanId BEFORE vm.prank to avoid consuming the prank
    291
            uint256 nextLoanId = loanEngine.getNextLoanId();
    292
            bytes memory proofData = abi.encodePacked(nextLoanId, userIndex, principalIssued, originationFeeBps, termDays);
    293
    294
    295
            vm.prank(deployer);
    296
            loanEngine.createLoan(
    297
                borrowerCommitment,
    298
                keccak256(abi.encode(nextLoanId,userIndex,borrowerCommitment, block.timestamp)), // nullifierHash
    299
                activePolicyVersion,
    300
                1,
    301
                principalIssued,
    302
                500,
    303
                originationFeeBps,
    304
                termDays,
    305
                bytes32(0), // industry
    306
                proofData,
    307
                new bytes32[](0)
    308
            );
    309
        }
    310
    311
        function activateLoan(uint256 loanId) public {
    312
            if (loanEngine.getNextLoanId() != 1) {
    313
                loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    314
            }
    315
    316
            if (
    317
                loanEngine.getLoanDetails(loanId).state !=
    318
                LoanEngine.LoanState.CREATED
    319
            ) {
    320
                return;
    321
            }
    322
    323
            if (
    324
                loanEngine.getLoanDetails(loanId).principalIssued >
    325
                tranchePool.getTotalIdleValue()
    326
            ) {
    327
                return;
    328
            }
    329
    330
            vm.prank(deployer);
    331
            loanEngine.activateLoan(loanId, recevingEntity, feeManager);
    332
            totalDeployedValue += loanEngine.getLoanDetails(loanId).principalIssued;
    333
            totalIdleValue -= loanEngine.getLoanDetails(loanId).principalIssued;
    334
            outStandingPrincipal += loanEngine
    335
                .getLoanDetails(loanId)
    336
                .principalIssued;
    337
        }
    338
    339
        function repayLoan(
    340
            uint256 loanId,
    341
            uint256 principalAmount,
    342
            uint256 interestAmount
    343
        ) public {
    344
            if (loanEngine.getNextLoanId() == 1) {
    345
                return;
    346
            }
    347
            loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    348
            LoanEngine.Loan memory loanDetails = loanEngine.getLoanDetails(loanId);
    349
            if (loanDetails.state != LoanEngine.LoanState.ACTIVE) {
    350
                return;
    351
            }
    352
            principalAmount = bound(
    353
                principalAmount,
    354
                0,
    355
                loanDetails.principalOutstanding
    356
            );
    357
    358
            uint256 pendingInterest = _accrueInterest(loanId);
    359
            uint256 totalInterestDue = loanDetails.interestAccrued + pendingInterest;
    360
    361
            interestAmount = bound(
    362
                interestAmount,
    363
                0,
    364
                totalInterestDue
    365
            );
    366
    367
            if (principalAmount == 0 && interestAmount == 0) {
    368
                return;
    369
            }
    370
    371
            if(principalAmount > 0 && interestAmount == 0 && totalInterestDue>0){
    372
                return;
    373
            }
    374
    375
            uint256 totalRepayAmount = principalAmount + interestAmount;
    376
            uint256 interestAccrued = loanDetails.interestAccrued +
    377
                _accrueInterest(loanId);
    378
            uint256 actualInterestPaid = _min(totalRepayAmount, interestAccrued);
    379
            uint256 actualPrincipalPaid = _min(
    380
                totalRepayAmount - actualInterestPaid,
    381
                loanDetails.principalOutstanding
    382
            );
    383
    384
            vm.prank(recevingEntity);
    385
            ERC20Mock(usdt).approve(address(loanEngine), totalRepayAmount);
    386
            vm.prank(deployer);
    387
            loanEngine.repayLoan(
    388
                loanId,
    389
                principalAmount,
    390
                interestAmount,
    391
                recevingEntity
    392
            );
    393
            totalDeployedValue -= actualPrincipalPaid;
    394
            totalIdleValue += actualPrincipalPaid;
    395
            outStandingPrincipal -= actualPrincipalPaid;
    396
        }
    397
    398
        function warpTime(uint256 daysToWarp) public {
    399
            daysToWarp = bound(daysToWarp, 1, 365);
    400
            vm.warp(block.timestamp + (daysToWarp * 1 days));
    401
        }
    402
    403
        function maybeDeclareDefault(uint256 loanId, bytes32 reasonHash) public {
    404
            if (loanEngine.getNextLoanId() == 1) {
    405
                return;
    406
            }
    407
            defaultCounter++;
    408
    409
            // 🔒 90% of the time → return
    410
            
    411
    412
            loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    413
    414
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
    415
    416
            if (loan.state != LoanEngine.LoanState.ACTIVE) {
    417
                return;
    418
            }
    419
    420
            vm.prank(deployer);
    421
            loanEngine.declareDefault(loanId, reasonHash);
    422
        }
    423
    424
        function maybeWriteOffLoan(uint256 loanId) public {
    425
            if (loanEngine.getNextLoanId() == 1) {
    426
                return;
    427
            }
    428
    429
            writeOffCounter++;
    430
    431
            // ~1 in 20 handler calls
    432
            
    433
    434
            loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    435
    436
            if (
    437
                loanEngine.getLoanDetails(loanId).state !=
    438
                LoanEngine.LoanState.DEFAULTED
    439
            ) {
    440
                return;
    441
            }
    442
    443
            // Read principal before writeoff as it zeroes it out
    444
            uint256 principalOutstanding = loanEngine
    445
                .getLoanDetails(loanId)
    446
                .principalOutstanding;
    447
    448
            vm.prank(deployer);
    449
            loanEngine.writeOffLoan(loanId);
    450
            totalDeployedValue -= principalOutstanding;
    451
            outStandingPrincipal -= principalOutstanding;
    452
            totalLoss += principalOutstanding;
    453
        }
    454
    455
        function maybeRecoverLoan(
    456
            uint256 loanId,
    457
            uint256 amount,
    458
            uint256 agentIndex
    459
        ) public {
    460
            if (loanEngine.getNextLoanId() == 1) {
    461
                return;
    462
            }
    463
            recoveryCounter++;
    464
    465
            // ~1 in 30 handler calls
    466
            if (recoveryCounter % 30 != 0) {
    467
                return;
    468
            }
    469
    470
            loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    471
    472
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
    473
            if (loan.state != LoanEngine.LoanState.WRITTEN_OFF) {
    474
                return;
    475
            }
    476
    477
            address recoveryAgent = recevingEntity;
    478
    479
            amount = bound(amount, 1, loan.principalIssued);
    480
    481
            vm.startPrank(recoveryAgent);
    482
            ERC20Mock(usdt).mint(recoveryAgent, amount);
    483
            ERC20Mock(usdt).approve(address(loanEngine), amount);
    484
            vm.stopPrank();
    485
    486
            vm.prank(deployer);
    487
            loanEngine.recoverLoan(loanId, amount, recoveryAgent);
    488
            totalIdleValue += amount;
    489
            totalRecovered += amount;
    490
        }
    491
    492
        // accounting functions for invariants
    493
    494
        function totalExpectedSeniorDeposits() public view returns (uint256) {
    495
            uint256 total;
    496
            for (uint256 i = 0; i < seniorUsers.length; i++) {
    497
                total += seniorTrancheDeposits[seniorUsers[i]];
    498
            }
    499
            return total;
    500
        }
    501
    502
        function totalExpectedJuniorDeposits() public view returns (uint256) {
    503
            uint256 total;
    504
            for (uint256 i = 0; i < juniorUsers.length; i++) {
    505
                total += juniorTrancheDeposits[juniorUsers[i]];
    506
            }
    507
            return total;
    508
        }
    509
    510
        function totalExpectedSeniorShares() public view returns (uint256) {
    511
            uint256 total;
    512
            for (uint256 i = 0; i < seniorUsers.length; i++) {
    513
                total += seniorTrancheShares[seniorUsers[i]];
    514
            }
    515
            return total;
    516
        }
    517
    518
        function totalExpectedJuniorShares() public view returns (uint256) {
    519
            uint256 total;
    520
            for (uint256 i = 0; i < juniorUsers.length; i++) {
    521
                total += juniorTrancheShares[juniorUsers[i]];
    522
            }
    523
            return total;
    524
        }
    525
    526
        function getSeniorTrancheIdleValue() public view returns (uint256) {
    527
            return seniorTrancheIdleValue;
    528
        }
    529
    530
        function getJuniorTrancheIdleValue() public view returns (uint256) {
    531
            return juniorTrancheIdleValue;
    532
        }
    533
    534
        function getSeniorTrancheTotalShares() public view returns (uint256) {
    535
            return seniorTrancheTotalShares;
    536
        }
    537
    538
        function getJuniorTrancheTotalShares() public view returns (uint256) {
    539
            return juniorTrancheTotalShares;
    540
        }
    541
    542
        function _min(uint256 a, uint256 b) internal pure returns (uint256) {
    543
            return a < b ? a : b;
    544
        }
    545
    546
        function _accrueInterest(uint256 loanId) internal view returns (uint256) {
    547
            // Implementation goes here
    548
            loanId = bound(loanId, 1, loanEngine.getNextLoanId() - 1);
    549
            LoanEngine.Loan memory loan = loanEngine.getLoanDetails(loanId);
    550
    551
            uint256 timeElapsed = block.timestamp - loan.lastAccrualTimestamp;
    552
            if (loan.principalOutstanding == 0) {
    553
                return 0;
    554
            }
    555
    556
            uint256 interest = (loan.principalOutstanding *
    557
                loan.aprBps *
    558
                timeElapsed) / (365 days * 10_000);
    559
    560
            return interest;
    561
        }
    562
    }
    563
    50.0% test/mocks/MockLoanProofVerifier.sol
    Lines covered: 1 / 2 (50.0%)
    1
    // SPDX-License-Identifier: MIT
    2
    pragma solidity ^0.8.24;
    3
    4
    contract MockLoanProofVerifier {
    5
        function verify(
    6
            bytes calldata proof,
    7
            bytes32[] calldata publicInputs
    8
        ) external pure returns (bool) {
    9
            return true;
    10
        }
    11
    }
    12